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

data/spec/functional/knife/exec_spec.rb

@@ -41,9 +41,7 @@ describe Chef::Knife::Exec do
     @server.stop
   end
 
-  pending "executes a script in the context of the chef-shell main context", :ruby_18_only
-
-  it "executes a script in the context of the chef-shell main context", :ruby_gte_19_only do
+  it "executes a script in the context of the chef-shell main context" do
     @node = Chef::Node.new
     @node.name("ohai-world")
     response = {"rows" => [@node],"start" => 0,"total" => 1}
@@ -51,7 +49,7 @@ describe Chef::Knife::Exec do
     code = "$output.puts nodes.all"
     @knife.config[:exec] = code
     @knife.run
-    $output.string.should match(%r{node\[ohai-world\]})
+    expect($output.string).to match(%r{node\[ohai-world\]})
   end
 
 end

data/spec/functional/knife/smoke_test.rb

@@ -29,6 +29,6 @@ describe "knife smoke tests" do
     knife_cmd = Mixlib::ShellOut.new("#{knife_path} -v")
     knife_cmd.run_command
     knife_cmd.error!
-    knife_cmd.stdout.should include(Chef::VERSION)
+    expect(knife_cmd.stdout).to include(Chef::VERSION)
   end
 end

data/spec/functional/knife/ssh_spec.rb

@@ -40,7 +40,7 @@ describe Chef::Knife::Ssh do
 
       it "uses the ssh_identity_file" do
         @knife.run
-        @knife.config[:identity_file].should == "~/.ssh/aws.rsa"
+        expect(@knife.config[:identity_file]).to eq("~/.ssh/aws.rsa")
       end
     end
 
@@ -52,7 +52,7 @@ describe Chef::Knife::Ssh do
 
       it "uses the ssh_identity_file" do
         @knife.run
-        @knife.config[:identity_file].should == "~/.ssh/aws.rsa"
+        expect(@knife.config[:identity_file]).to eq("~/.ssh/aws.rsa")
       end
     end
 
@@ -64,13 +64,13 @@ describe Chef::Knife::Ssh do
 
       it "should use the value on the command line" do
         @knife.run
-        @knife.config[:identity_file].should == "~/.ssh/aws.rsa"
+        expect(@knife.config[:identity_file]).to eq("~/.ssh/aws.rsa")
       end
 
       it "should override what is set in knife.rb" do
         Chef::Config[:knife][:ssh_identity_file] = "~/.ssh/other.rsa"
         @knife.run
-        @knife.config[:identity_file].should == "~/.ssh/aws.rsa"
+        expect(@knife.config[:identity_file]).to eq("~/.ssh/aws.rsa")
       end
     end
 
@@ -82,7 +82,7 @@ describe Chef::Knife::Ssh do
 
       it "uses the default" do
         @knife.run
-        @knife.config[:identity_file].should == nil
+        expect(@knife.config[:identity_file]).to eq(nil)
       end
     end
   end
@@ -95,7 +95,7 @@ describe Chef::Knife::Ssh do
 
       it "uses the ssh_port" do
         @knife.run
-        @knife.config[:ssh_port].should == "31337"
+        expect(@knife.config[:ssh_port]).to eq("31337")
       end
     end
   end
@@ -109,7 +109,7 @@ describe Chef::Knife::Ssh do
 
       it "uses the ssh_user" do
         @knife.run
-        @knife.config[:ssh_user].should == "ubuntu"
+        expect(@knife.config[:ssh_user]).to eq("ubuntu")
       end
     end
 
@@ -121,7 +121,7 @@ describe Chef::Knife::Ssh do
 
       it "uses the ssh_user" do
         @knife.run
-        @knife.config[:ssh_user].should == "ubuntu"
+        expect(@knife.config[:ssh_user]).to eq("ubuntu")
       end
     end
 
@@ -133,13 +133,13 @@ describe Chef::Knife::Ssh do
 
       it "should use the value on the command line" do
         @knife.run
-        @knife.config[:ssh_user].should == "ubuntu"
+        expect(@knife.config[:ssh_user]).to eq("ubuntu")
       end
 
       it "should override what is set in knife.rb" do
         Chef::Config[:knife][:ssh_user] = "root"
         @knife.run
-        @knife.config[:ssh_user].should == "ubuntu"
+        expect(@knife.config[:ssh_user]).to eq("ubuntu")
       end
     end
 
@@ -151,7 +151,7 @@ describe Chef::Knife::Ssh do
 
       it "uses the default (current user)" do
         @knife.run
-        @knife.config[:ssh_user].should == nil
+        expect(@knife.config[:ssh_user]).to eq(nil)
       end
     end
   end
@@ -165,7 +165,7 @@ describe Chef::Knife::Ssh do
 
       it "uses the ssh_attribute" do
         @knife.run
-        @knife.config[:attribute].should == "ec2.public_hostname"
+        expect(@knife.config[:attribute]).to eq("ec2.public_hostname")
       end
     end
 
@@ -177,7 +177,7 @@ describe Chef::Knife::Ssh do
 
       it "uses the default" do
         @knife.run
-        @knife.config[:attribute].should == "fqdn"
+        expect(@knife.config[:attribute]).to eq("fqdn")
       end
     end
 
@@ -189,7 +189,7 @@ describe Chef::Knife::Ssh do
 
       it "should use the value on the command line" do
         @knife.run
-        @knife.config[:attribute].should == "ec2.public_hostname"
+        expect(@knife.config[:attribute]).to eq("ec2.public_hostname")
       end
 
       it "should override what is set in knife.rb" do
@@ -198,7 +198,7 @@ describe Chef::Knife::Ssh do
         # Then we run knife with the -a flag, which sets the above variable
         setup_knife(['-a ec2.public_hostname', '*:*', 'uptime'])
         @knife.run
-        @knife.config[:attribute].should == "ec2.public_hostname"
+        expect(@knife.config[:attribute]).to eq("ec2.public_hostname")
       end
     end
   end
@@ -211,9 +211,9 @@ describe Chef::Knife::Ssh do
       end
 
       it "uses the ssh_gateway" do
-        @knife.session.should_receive(:via).with("ec2.public_hostname", "user", {})
+        expect(@knife.session).to receive(:via).with("ec2.public_hostname", "user", {})
         @knife.run
-        @knife.config[:ssh_gateway].should == "user@ec2.public_hostname"
+        expect(@knife.config[:ssh_gateway]).to eq("user@ec2.public_hostname")
       end
     end
 
@@ -224,9 +224,9 @@ describe Chef::Knife::Ssh do
       end
 
       it "uses the ssh_gateway" do
-        @knife.session.should_receive(:via).with("ec2.public_hostname", "user", {})
+        expect(@knife.session).to receive(:via).with("ec2.public_hostname", "user", {})
         @knife.run
-        @knife.config[:ssh_gateway].should == "user@ec2.public_hostname"
+        expect(@knife.config[:ssh_gateway]).to eq("user@ec2.public_hostname")
       end
     end
 
@@ -234,13 +234,13 @@ describe Chef::Knife::Ssh do
       before do
         setup_knife(['-G user@ec2.public_hostname', '*:*', 'uptime'])
         Chef::Config[:knife][:ssh_gateway] = nil
-        @knife.session.stub(:via) do |host, user, options|
+        allow(@knife.session).to receive(:via) do |host, user, options|
           raise Net::SSH::AuthenticationFailed unless options[:password]
         end
       end
 
       it "should prompt the user for a password" do
-        @knife.ui.should_receive(:ask).with("Enter the password for user@ec2.public_hostname: ").and_return("password")
+        expect(@knife.ui).to receive(:ask).with("Enter the password for user@ec2.public_hostname: ").and_return("password")
         @knife.run
       end
     end
@@ -252,7 +252,7 @@ describe Chef::Knife::Ssh do
     # if available, but #merge_configs (which is called by #configure_chef) is
     # necessary to have default options merged in.
     @knife.merge_configs
-    @knife.stub(:ssh_command).and_return { 0 }
+    allow(@knife).to receive(:ssh_command) { 0 }
     @api = TinyServer::API.instance
     @api.clear
 
@@ -260,7 +260,7 @@ describe Chef::Knife::Ssh do
     Chef::Config[:client_key] = nil
     Chef::Config[:chef_server_url] = 'http://localhost:9000'
 
-    @api.get("/search/node?q=*:*&sort=X_CHEF_id_CHEF_X%20asc&start=0&rows=1000", 200) {
+    @api.get("/search/node?q=*:*&sort=X_CHEF_id_CHEF_X%20asc&start=0", 200) {
       %({"total":1, "start":0, "rows":[{"name":"i-xxxxxxxx", "json_class":"Chef::Node", "automatic":{"fqdn":"the.fqdn", "ec2":{"public_hostname":"the_public_hostname"}},"recipes":[]}]})
     }
   end

data/spec/functional/provider/remote_file/cache_control_data_spec.rb

@@ -64,9 +64,9 @@ describe Chef::Provider::RemoteFile::CacheControlData do
     it "writes the data to the cache and the same data can be read back" do
       cache_control_data.save
       saved_cache_control_data = Chef::Provider::RemoteFile::CacheControlData.load_and_validate(uri, file_checksum)
-      saved_cache_control_data.etag.should == cache_control_data.etag
-      saved_cache_control_data.mtime.should == cache_control_data.mtime
-      saved_cache_control_data.checksum.should == cache_control_data.checksum  
+      expect(saved_cache_control_data.etag).to eq(cache_control_data.etag)
+      expect(saved_cache_control_data.mtime).to eq(cache_control_data.mtime)
+      expect(saved_cache_control_data.checksum).to eq(cache_control_data.checksum)  
     end
 
     # Cover the very long remote file path case -- see CHEF-4422 where
@@ -81,17 +81,17 @@ describe Chef::Provider::RemoteFile::CacheControlData do
       let(:uri) { uri_exceeds_file_system_limit }
 
       it "writes data to the cache" do
-        lambda do
+        expect do
           cache_control_data.save
-        end.should_not raise_error
+        end.not_to raise_error
       end
 
       it "writes the data to the cache and the same data can be read back" do
         cache_control_data.save
         saved_cache_control_data = Chef::Provider::RemoteFile::CacheControlData.load_and_validate(uri, file_checksum)
-        saved_cache_control_data.etag.should == cache_control_data.etag
-        saved_cache_control_data.mtime.should == cache_control_data.mtime
-        saved_cache_control_data.checksum.should == cache_control_data.checksum  
+        expect(saved_cache_control_data.etag).to eq(cache_control_data.etag)
+        expect(saved_cache_control_data.mtime).to eq(cache_control_data.mtime)
+        expect(saved_cache_control_data.checksum).to eq(cache_control_data.checksum)  
       end
 
     end

data/spec/functional/provider/whyrun_safe_ruby_block_spec.rb

@@ -44,8 +44,8 @@ describe Chef::Resource::WhyrunSafeRubyBlock do
 
     it "updates the evil laugh, even in why-run mode" do
       new_resource.run_action(new_resource.action)
-      $evil_global_evil_laugh.should == :mwahahaha
-      new_resource.should be_updated
+      expect($evil_global_evil_laugh).to eq(:mwahahaha)
+      expect(new_resource).to be_updated
     end
   end
 end

data/spec/functional/rebooter_spec.rb

@@ -70,7 +70,7 @@ describe Chef::Platform::Rebooter do
 
       shared_context 'test a reboot method' do
         def test_rebooter_method(method_sym, is_windows, expected_reboot_str)
-          Chef::Platform.stub(:windows?).and_return(is_windows)
+          allow(Chef::Platform).to receive(:windows?).and_return(is_windows)
           expect(rebooter).to receive(:shell_out!).once.with(expected_reboot_str)
           expect(rebooter).to receive(method_sym).once.and_call_original
           rebooter.send(method_sym, run_context.node)

data/spec/functional/resource/aix_service_spec.rb

@@ -73,6 +73,9 @@ shared_examples "src service" do
 end
 
 describe Chef::Resource::Service, :requires_root, :aix_only do
+
+  include Chef::Mixin::ShellOut
+
   def get_user_id
     shell_out("id -u #{ENV['USER']}").stdout.chomp
   end

data/spec/functional/resource/aixinit_service_spec.rb

@@ -28,12 +28,12 @@ describe Chef::Resource::Service, :requires_root, :aix_only do
 
   # Platform specific validation routines.
   def service_should_be_started(file_name)
-    # The existance of this file indicates that the service was started.
-    expect(File.exists?("/tmp/#{file_name}")).to be_true
+    # The existence of this file indicates that the service was started.
+    expect(File.exists?("/tmp/#{file_name}")).to be_truthy
   end
 
   def service_should_be_stopped(file_name)
-    expect(File.exists?("/tmp/#{file_name}")).to be_false
+    expect(File.exists?("/tmp/#{file_name}")).to be_falsey
   end
 
   def valide_symlinks(expected_output, run_level = nil, status = nil, priority = nil)

data/spec/functional/resource/bash_spec.rb

@@ -0,0 +1,88 @@
+#
+# Author:: Serdar Sutay (<serdar@opscode.com>)
+# Copyright:: Copyright (c) 2014 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+require 'functional/resource/base'
+
+describe Chef::Resource::Bash, :unix_only do
+  let(:code) { "echo hello" }
+  let(:resource) {
+    resource = Chef::Resource::Bash.new("foo_resource", run_context)
+    resource.code(code)
+    resource
+  }
+
+  describe "when setting the command attribute" do
+    let (:command) { 'wizard racket' }
+
+    # in Chef-12 the `command` attribute is largely useless, but does set the identity attribute
+    # so that notifications need to target the value of the command.  it will not run the `command`
+    # and if it is given without a code block then it does nothing and always succeeds.
+    describe "in Chef-12", :chef_lt_13_only do
+      it "gets the commmand attribute from the name" do
+        expect(resource.command).to eql("foo_resource")
+      end
+
+      it "sets the resource identity to the command name" do
+        resource.command command
+        expect(resource.identity).to eql(command)
+      end
+
+      it "warns when the code is not present and a useless `command` is present" do
+        expect(Chef::Log).to receive(:warn).with(/coding error/)
+        expect(Chef::Log).to receive(:warn).with(/deprecated/)
+        resource.code nil
+        resource.command command
+        expect { resource.run_action(:run) }.not_to raise_error
+      end
+
+      describe "when the code is not present" do
+        let(:code) { nil }
+        it "warns" do
+          expect(Chef::Log).to receive(:warn)
+          expect { resource.run_action(:run) }.not_to raise_error
+        end
+      end
+    end
+
+    # in Chef-13 the `command` attribute needs to be for internal use only
+    describe "in Chef-13", :chef_gte_13_only do
+      it "should raise an exception when trying to set the command" do
+        expect { resource.command command }.to raise_error # FIXME: add a real error in Chef-13
+      end
+
+      it "should initialize the command to nil" do
+        expect(resource.command).to be_nil
+      end
+
+      describe "when the code is not present" do
+        let(:code) { nil }
+        it "raises an exception" do
+          expect { resource.run_action(:run) }.to raise_error # FIXME: add a real error in Chef-13
+          expect { resource.run_action(:run) }.not_to raise_error
+        end
+      end
+    end
+  end
+
+  it "times out when a timeout is set on the resource" do
+    resource.code 'sleep 600'
+    resource.timeout 0.1
+    expect { resource.run_action(:run) }.to raise_error(Mixlib::ShellOut::CommandTimeout)
+  end
+end

data/spec/functional/resource/deploy_revision_spec.rb

@@ -45,11 +45,10 @@ describe Chef::Resource::DeployRevision, :unix_only => true do
 
   before(:all) do
     @ohai = Ohai::System.new
-    @ohai.all_plugins("os")
+    @ohai.all_plugins(["platform", "os"])
   end
 
   let(:node) do
-
     Chef::Node.new.tap do |n|
       n.name "rspec-test"
       n.consume_external_attrs(@ohai.data, {})
@@ -173,12 +172,12 @@ describe Chef::Resource::DeployRevision, :unix_only => true do
     it "deploys the app to the target revision (#{target_rev_spec})" do
       target_rev = send(target_rev_spec)
 
-      File.should exist(rel_path("current"))
+      expect(File).to exist(rel_path("current"))
 
-      actual_current_rev.should == target_rev
+      expect(actual_current_rev).to eq(target_rev)
 
       # Is the app code actually there?
-      File.should exist(rel_path("current/app/app.rb"))
+      expect(File).to exist(rel_path("current/app/app.rb"))
     end
   end
 
@@ -193,12 +192,12 @@ describe Chef::Resource::DeployRevision, :unix_only => true do
       the_app_is_deployed_at_revision(:latest_rev)
 
       it "restarts the application" do
-        File.should exist(rel_path("current/restart.txt"))
-        actual_operations_order.should == %w[deploy_to_latest_rev]
+        expect(File).to exist(rel_path("current/restart.txt"))
+        expect(actual_operations_order).to eq(%w[deploy_to_latest_rev])
       end
 
       it "is marked as updated" do
-        deploy_to_latest_rev.should be_updated_by_last_action
+        expect(deploy_to_latest_rev).to be_updated_by_last_action
       end
     end
 
@@ -215,15 +214,15 @@ describe Chef::Resource::DeployRevision, :unix_only => true do
       the_app_is_deployed_at_revision(:latest_rev)
 
       it "restarts the application after rolling back" do
-        actual_operations_order.should == %w[deploy_to_latest_rev deploy_to_previous_rev deploy_to_latest_rev_again]
+        expect(actual_operations_order).to eq(%w[deploy_to_latest_rev deploy_to_previous_rev deploy_to_latest_rev_again])
       end
 
       it "is marked updated" do
-        deploy_to_latest_rev_again.should be_updated_by_last_action
+        expect(deploy_to_latest_rev_again).to be_updated_by_last_action
       end
 
       it "deploys the right code" do
-        IO.read(rel_path("current/app/app.rb")).should include("this is the fourth version of the app")
+        expect(IO.read(rel_path("current/app/app.rb"))).to include("this is the fourth version of the app")
       end
     end
 
@@ -233,27 +232,27 @@ describe Chef::Resource::DeployRevision, :unix_only => true do
       end
 
       it "creates the required directory tree" do
-        File.should be_directory(rel_path("releases"))
-        File.should be_directory(rel_path("shared"))
-        File.should be_directory(rel_path("releases/#{latest_rev}"))
+        expect(File).to be_directory(rel_path("releases"))
+        expect(File).to be_directory(rel_path("shared"))
+        expect(File).to be_directory(rel_path("releases/#{latest_rev}"))
 
-        File.should be_directory(rel_path("current/tmp"))
-        File.should be_directory(rel_path("current/config"))
-        File.should be_directory(rel_path("current/public"))
+        expect(File).to be_directory(rel_path("current/tmp"))
+        expect(File).to be_directory(rel_path("current/config"))
+        expect(File).to be_directory(rel_path("current/public"))
 
-        File.should be_symlink(rel_path("current"))
-        File.readlink(rel_path("current")).should == rel_path("releases/#{latest_rev}")
+        expect(File).to be_symlink(rel_path("current"))
+        expect(File.readlink(rel_path("current"))).to eq(rel_path("releases/#{latest_rev}"))
       end
 
       the_app_is_deployed_at_revision(:latest_rev)
 
       it "restarts the application" do
-        File.should exist(rel_path("current/restart.txt"))
-        actual_operations_order.should == %w[deploy_to_latest_rev]
+        expect(File).to exist(rel_path("current/restart.txt"))
+        expect(actual_operations_order).to eq(%w[deploy_to_latest_rev])
       end
 
       it "is marked as updated" do
-        deploy_to_latest_rev.should be_updated_by_last_action
+        expect(deploy_to_latest_rev).to be_updated_by_last_action
       end
     end
 
@@ -266,11 +265,11 @@ describe Chef::Resource::DeployRevision, :unix_only => true do
       the_app_is_deployed_at_revision(:latest_rev)
 
       it "does not restart the app" do
-        actual_operations_order.should == %w[deploy_to_latest_rev]
+        expect(actual_operations_order).to eq(%w[deploy_to_latest_rev])
       end
 
       it "is not marked updated" do
-        deploy_to_latest_rev.should_not be_updated_by_last_action
+        expect(deploy_to_latest_rev).not_to be_updated_by_last_action
       end
 
     end
@@ -284,11 +283,11 @@ describe Chef::Resource::DeployRevision, :unix_only => true do
       the_app_is_deployed_at_revision(:latest_rev)
 
       it "restarts the app" do
-        actual_operations_order.should == %w[deploy_to_latest_rev deploy_to_latest_rev_again]
+        expect(actual_operations_order).to eq(%w[deploy_to_latest_rev deploy_to_latest_rev_again])
       end
 
       it "is marked updated" do
-        deploy_to_latest_rev.should be_updated_by_last_action
+        expect(deploy_to_latest_rev).to be_updated_by_last_action
       end
 
     end
@@ -302,15 +301,15 @@ describe Chef::Resource::DeployRevision, :unix_only => true do
       the_app_is_deployed_at_revision(:latest_rev)
 
       it "restarts the application after the new deploy" do
-        actual_operations_order.should == %w[deploy_to_previous_rev deploy_to_latest_rev]
+        expect(actual_operations_order).to eq(%w[deploy_to_previous_rev deploy_to_latest_rev])
       end
 
       it "is marked updated" do
-        deploy_to_previous_rev.should be_updated_by_last_action
+        expect(deploy_to_previous_rev).to be_updated_by_last_action
       end
 
       it "leaves the old copy of the app around for rollback" do
-        File.should exist(File.join(deploy_directory, "releases", previous_rev))
+        expect(File).to exist(File.join(deploy_directory, "releases", previous_rev))
       end
 
     end
@@ -325,15 +324,15 @@ describe Chef::Resource::DeployRevision, :unix_only => true do
       the_app_is_deployed_at_revision(:latest_rev)
 
       it "restarts the application after rolling back" do
-        actual_operations_order.should == %w[deploy_to_latest_rev deploy_to_previous_rev deploy_to_latest_rev_again]
+        expect(actual_operations_order).to eq(%w[deploy_to_latest_rev deploy_to_previous_rev deploy_to_latest_rev_again])
       end
 
       it "is marked updated" do
-        deploy_to_latest_rev_again.should be_updated_by_last_action
+        expect(deploy_to_latest_rev_again).to be_updated_by_last_action
       end
 
       it "deploys the right code" do
-        IO.read(rel_path("current/app/app.rb")).should include("this is the fourth version of the app")
+        expect(IO.read(rel_path("current/app/app.rb"))).to include("this is the fourth version of the app")
       end
     end
 
@@ -350,31 +349,31 @@ describe Chef::Resource::DeployRevision, :unix_only => true do
       the_app_is_deployed_at_revision(:previous_rev)
 
       it "restarts the application after rolling back" do
-        actual_operations_order.should == %w[deploy_to_previous_rev deploy_to_latest_rev deploy_to_latest_rev_again]
+        expect(actual_operations_order).to eq(%w[deploy_to_previous_rev deploy_to_latest_rev deploy_to_latest_rev_again])
       end
 
       it "is marked updated" do
-        deploy_to_latest_rev_again.should be_updated_by_last_action
+        expect(deploy_to_latest_rev_again).to be_updated_by_last_action
       end
 
       it "deploys the right code" do
-        IO.read(rel_path("current/app/app.rb")).should include("this is the third version of the app")
+        expect(IO.read(rel_path("current/app/app.rb"))).to include("this is the third version of the app")
       end
 
       it "all_releases after first deploy should have one entry" do
-        @previous_rev_all_releases.length.should == 1
+        expect(@previous_rev_all_releases.length).to eq(1)
       end
 
       it "all_releases after second deploy should have two entries" do
-        @latest_rev_all_releases.length.should == 2
+        expect(@latest_rev_all_releases.length).to eq(2)
       end
 
       it "all_releases after rollback should have one entry" do
-        @previous_rev_again_all_releases.length.should == 1
+        expect(@previous_rev_again_all_releases.length).to eq(1)
       end
 
       it "all_releases after rollback should be the same as after the first deploy" do
-        @previous_rev_again_all_releases.should == @previous_rev_all_releases
+        expect(@previous_rev_again_all_releases).to eq(@previous_rev_all_releases)
       end
 
     end
@@ -393,31 +392,31 @@ describe Chef::Resource::DeployRevision, :unix_only => true do
       the_app_is_deployed_at_revision(:previous_rev)
 
       it "restarts the application after rolling back" do
-        actual_operations_order.should == %w[deploy_to_previous_rev deploy_to_latest_rev deploy_to_previous_rev_again]
+        expect(actual_operations_order).to eq(%w[deploy_to_previous_rev deploy_to_latest_rev deploy_to_previous_rev_again])
       end
 
       it "is marked updated" do
-        deploy_to_previous_rev_again.should be_updated_by_last_action
+        expect(deploy_to_previous_rev_again).to be_updated_by_last_action
       end
 
       it "deploys the right code" do
-        IO.read(rel_path("current/app/app.rb")).should include("this is the third version of the app")
+        expect(IO.read(rel_path("current/app/app.rb"))).to include("this is the third version of the app")
       end
 
       it "all_releases after first deploy should have one entry" do
-        @previous_rev_all_releases.length.should == 1
+        expect(@previous_rev_all_releases.length).to eq(1)
       end
 
       it "all_releases after second deploy should have two entries" do
-        @latest_rev_all_releases.length.should == 2
+        expect(@latest_rev_all_releases.length).to eq(2)
       end
 
       it "all_releases after rollback should have one entry" do
-        @previous_rev_again_all_releases.length.should == 1
+        expect(@previous_rev_again_all_releases.length).to eq(1)
       end
 
       it "all_releases after rollback should be the same as after the first deploy" do
-        @previous_rev_again_all_releases.should == @previous_rev_all_releases
+        expect(@previous_rev_again_all_releases).to eq(@previous_rev_all_releases)
       end
     end
 
@@ -438,23 +437,23 @@ describe Chef::Resource::DeployRevision, :unix_only => true do
       the_app_is_deployed_at_revision(:second_rev)
 
       it "restarts the application after rolling back" do
-        actual_operations_order.should == %w[deploy_to_second_rev deploy_to_previous_rev deploy_to_previous_rev_again deploy_to_latest_rev deploy_to_latest_rev_again]
+        expect(actual_operations_order).to eq(%w[deploy_to_second_rev deploy_to_previous_rev deploy_to_previous_rev_again deploy_to_latest_rev deploy_to_latest_rev_again])
       end
 
       it "is marked updated" do
-        deploy_to_latest_rev_again.should be_updated_by_last_action
+        expect(deploy_to_latest_rev_again).to be_updated_by_last_action
       end
 
       it "deploys the right code" do
-        IO.read(rel_path("current/app/app.rb")).should include("this is the second version of the app")
+        expect(IO.read(rel_path("current/app/app.rb"))).to include("this is the second version of the app")
       end
 
       it "all_releases after rollback should have one entry" do
-        @fifth_deploy_all_releases.length.should == 1
+        expect(@fifth_deploy_all_releases.length).to eq(1)
       end
 
       it "all_releases after rollback should be the same as after the first deploy" do
-        @fifth_deploy_all_releases.should == @first_deploy_all_releases
+        expect(@fifth_deploy_all_releases).to eq(@first_deploy_all_releases)
       end
     end
 
@@ -475,23 +474,23 @@ describe Chef::Resource::DeployRevision, :unix_only => true do
       the_app_is_deployed_at_revision(:second_rev)
 
       it "restarts the application after rolling back" do
-        actual_operations_order.should == %w[deploy_to_second_rev deploy_to_previous_rev deploy_to_second_rev_again deploy_to_latest_rev deploy_to_second_rev_again_again]
+        expect(actual_operations_order).to eq(%w[deploy_to_second_rev deploy_to_previous_rev deploy_to_second_rev_again deploy_to_latest_rev deploy_to_second_rev_again_again])
       end
 
       it "is marked updated" do
-        deploy_to_second_rev_again_again.should be_updated_by_last_action
+        expect(deploy_to_second_rev_again_again).to be_updated_by_last_action
       end
 
       it "deploys the right code" do
-        IO.read(rel_path("current/app/app.rb")).should include("this is the second version of the app")
+        expect(IO.read(rel_path("current/app/app.rb"))).to include("this is the second version of the app")
       end
 
       it "all_releases after rollback should have one entry" do
-        @fifth_deploy_all_releases.length.should == 1
+        expect(@fifth_deploy_all_releases.length).to eq(1)
       end
 
       it "all_releases after rollback should be the same as after the first deploy" do
-        @fifth_deploy_all_releases.should == @first_deploy_all_releases
+        expect(@fifth_deploy_all_releases).to eq(@first_deploy_all_releases)
       end
 
     end
@@ -510,21 +509,21 @@ describe Chef::Resource::DeployRevision, :unix_only => true do
       end
 
       before do
-        File.should_not exist(deploy_directory)
+        expect(File).not_to exist(deploy_directory)
         deploy_to_latest_rev.run_action(:deploy)
       end
 
       it "creates the required directory tree" do
-        File.should be_directory(rel_path("releases"))
-        File.should be_directory(rel_path("shared"))
-        File.should be_directory(rel_path("releases/#{latest_rev}"))
+        expect(File).to be_directory(rel_path("releases"))
+        expect(File).to be_directory(rel_path("shared"))
+        expect(File).to be_directory(rel_path("releases/#{latest_rev}"))
 
-        File.should be_directory(rel_path("current/tmp"))
-        File.should be_directory(rel_path("current/config"))
-        File.should be_directory(rel_path("current/public"))
+        expect(File).to be_directory(rel_path("current/tmp"))
+        expect(File).to be_directory(rel_path("current/config"))
+        expect(File).to be_directory(rel_path("current/public"))
 
-        File.should be_symlink(rel_path("current"))
-        File.readlink(rel_path("current")).should == rel_path("releases/#{latest_rev}")
+        expect(File).to be_symlink(rel_path("current"))
+        expect(File.readlink(rel_path("current"))).to eq(rel_path("releases/#{latest_rev}"))
       end
 
       the_app_is_deployed_at_revision(:latest_rev)
@@ -599,18 +598,18 @@ describe Chef::Resource::DeployRevision, :unix_only => true do
     the_app_is_deployed_at_revision(:latest_rev)
 
     it "is marked updated" do
-      deploy_to_latest_with_inline_recipes.should be_updated_by_last_action
+      expect(deploy_to_latest_with_inline_recipes).to be_updated_by_last_action
     end
 
     it "calls the callbacks in order" do
-      callback_order.should == [:before_migrate, :before_symlink, :before_restart, :after_restart]
+      expect(callback_order).to eq([:before_migrate, :before_symlink, :before_restart, :after_restart])
     end
 
     it "runs chef resources in the callbacks" do
-      File.should exist(rel_path("current/before_migrate.txt"))
-      File.should exist(rel_path("current/before_symlink.txt"))
-      File.should exist(rel_path("current/tmp/before_restart.txt"))
-      File.should exist(rel_path("current/tmp/after_restart.txt"))
+      expect(File).to exist(rel_path("current/before_migrate.txt"))
+      expect(File).to exist(rel_path("current/before_symlink.txt"))
+      expect(File).to exist(rel_path("current/tmp/before_restart.txt"))
+      expect(File).to exist(rel_path("current/tmp/after_restart.txt"))
     end
   end
 
@@ -629,10 +628,10 @@ describe Chef::Resource::DeployRevision, :unix_only => true do
     the_app_is_deployed_at_revision(:rev_with_in_repo_callbacks)
 
     it "runs chef resources in the callbacks" do
-      File.should exist(rel_path("current/before_migrate.txt"))
-      File.should exist(rel_path("current/before_symlink.txt"))
-      File.should exist(rel_path("current/tmp/before_restart.txt"))
-      File.should exist(rel_path("current/tmp/after_restart.txt"))
+      expect(File).to exist(rel_path("current/before_migrate.txt"))
+      expect(File).to exist(rel_path("current/before_symlink.txt"))
+      expect(File).to exist(rel_path("current/tmp/before_restart.txt"))
+      expect(File).to exist(rel_path("current/tmp/after_restart.txt"))
     end
 
   end
@@ -690,7 +689,7 @@ describe Chef::Resource::DeployRevision, :unix_only => true do
     end
 
     it "runs migrations in between the before_migrate and before_symlink steps" do
-      actual_operations_order.should == %w[before_migrate migration before_symlink before_restart after_restart]
+      expect(actual_operations_order).to eq(%w[before_migrate migration before_symlink before_restart after_restart])
     end
   end
 
@@ -703,7 +702,7 @@ describe Chef::Resource::DeployRevision, :unix_only => true do
     end
 
     it "should not raise an exception calling File.utime on symlinks" do
-      lambda { deploy_with_in_repo_symlinks.run_action(:deploy) }.should_not raise_error
+      expect { deploy_with_in_repo_symlinks.run_action(:deploy) }.not_to raise_error
     end
   end
 
@@ -712,16 +711,16 @@ describe Chef::Resource::DeployRevision, :unix_only => true do
     shared_examples_for "a redeployed application" do
 
       it "should redeploy the application" do
-        File.should be_directory(rel_path("releases"))
-        File.should be_directory(rel_path("shared"))
-        File.should be_directory(rel_path("releases/#{latest_rev}"))
+        expect(File).to be_directory(rel_path("releases"))
+        expect(File).to be_directory(rel_path("shared"))
+        expect(File).to be_directory(rel_path("releases/#{latest_rev}"))
 
-        File.should be_directory(rel_path("current/tmp"))
-        File.should be_directory(rel_path("current/config"))
-        File.should be_directory(rel_path("current/public"))
+        expect(File).to be_directory(rel_path("current/tmp"))
+        expect(File).to be_directory(rel_path("current/config"))
+        expect(File).to be_directory(rel_path("current/public"))
 
-        File.should be_symlink(rel_path("current"))
-        File.readlink(rel_path("current")).should == rel_path("releases/#{latest_rev}")
+        expect(File).to be_symlink(rel_path("current"))
+        expect(File.readlink(rel_path("current"))).to eq(rel_path("releases/#{latest_rev}"))
       end
     end
 
@@ -758,23 +757,23 @@ describe Chef::Resource::DeployRevision, :unix_only => true do
     shared_examples_for "a recovered deployment" do
 
       it "should redeploy the application" do
-        File.should be_directory(rel_path("releases"))
-        File.should be_directory(rel_path("shared"))
-        File.should be_directory(rel_path("releases/#{latest_rev}"))
+        expect(File).to be_directory(rel_path("releases"))
+        expect(File).to be_directory(rel_path("shared"))
+        expect(File).to be_directory(rel_path("releases/#{latest_rev}"))
 
-        File.should be_directory(rel_path("current/tmp"))
-        File.should be_directory(rel_path("current/config"))
-        File.should be_directory(rel_path("current/public"))
+        expect(File).to be_directory(rel_path("current/tmp"))
+        expect(File).to be_directory(rel_path("current/config"))
+        expect(File).to be_directory(rel_path("current/public"))
 
-        File.should be_symlink(rel_path("current"))
-        File.readlink(rel_path("current")).should == rel_path("releases/#{latest_rev}")
+        expect(File).to be_symlink(rel_path("current"))
+        expect(File.readlink(rel_path("current"))).to eq(rel_path("releases/#{latest_rev}"))
 
         # if callbacks ran, we know the app was deployed and not merely rolled
         # back to a (busted) prior deployment.
-        callback_order.should == [:before_migrate,
+        expect(callback_order).to eq([:before_migrate,
                                   :before_symlink,
                                   :before_restart,
-                                  :after_restart ]
+                                  :after_restart ])
       end
     end
 
@@ -794,7 +793,7 @@ describe Chef::Resource::DeployRevision, :unix_only => true do
 
       context "in the `#{callback}' callback" do
         before do
-          lambda { deploy_that_fails.run_action(:deploy) }.should raise_error(Exception, %r{I am a failed deploy})
+          expect { deploy_that_fails.run_action(:deploy) }.to raise_error(Exception, %r{I am a failed deploy})
           deploy_to_latest_with_callback_tracking.run_action(:deploy)
         end
 
@@ -820,7 +819,7 @@ describe Chef::Resource::DeployRevision, :unix_only => true do
       end
 
       before do
-        lambda { deploy_that_fails.run_action(:deploy) }.should raise_error(Chef::Exceptions::Exec)
+        expect { deploy_that_fails.run_action(:deploy) }.to raise_error(Chef::Exceptions::Exec)
         deploy_to_latest_with_callback_tracking.run_action(:deploy)
       end
 
@@ -852,7 +851,7 @@ describe Chef::Resource::DeployRevision, :unix_only => true do
       end
 
       before do
-        lambda { deploy_that_fails.run_action(:deploy) }.should raise_error(RuntimeError, /network error/)
+        expect { deploy_that_fails.run_action(:deploy) }.to raise_error(RuntimeError, /network error/)
         deploy_to_latest_with_callback_tracking.run_action(:deploy)
       end
 
@@ -868,12 +867,12 @@ describe Chef::Resource::DeployRevision, :unix_only => true do
       end
 
       before do
-        lambda { deploy_that_fails.run_action(:deploy) }.should raise_error(Exception, %r{I am a failed deploy})
+        expect { deploy_that_fails.run_action(:deploy) }.to raise_error(Exception, %r{I am a failed deploy})
         deploy_to_latest_rev.run_action(:deploy)
       end
 
       it "removes the unsuccessful deploy after a later successful deploy" do
-        ::File.should_not exist(File.join(deploy_directory, "releases", previous_rev))
+        expect(::File).not_to exist(File.join(deploy_directory, "releases", previous_rev))
       end
 
     end