chef 11.10.0.rc.0-x86-mingw32 → 11.10.0.rc.1-x86-mingw32

data/spec/unit/provider/env_spec.rb

@@ -36,10 +36,10 @@ describe Chef::Provider::Env do
   describe "when loading the current status" do
     before do
       #@current_resource = @new_resource.clone
-      #Chef::Resource::Env.stub!(:new).and_return(@current_resource)
+      #Chef::Resource::Env.stub(:new).and_return(@current_resource)
       @provider.current_resource = @current_resource
-      @provider.stub!(:env_value).with("FOO").and_return("bar")
-      @provider.stub!(:env_key_exists).and_return(true)
+      @provider.stub(:env_value).with("FOO").and_return("bar")
+      @provider.stub(:env_key_exists).and_return(true)
     end
 
     it "should create a current resource with the same name as the new resource" do
@@ -72,8 +72,8 @@ describe Chef::Provider::Env do
   describe "action_create" do
     before do
       @provider.key_exists = false
-      @provider.stub!(:create_env).and_return(true)
-      @provider.stub!(:modify_env).and_return(true)
+      @provider.stub(:create_env).and_return(true)
+      @provider.stub(:modify_env).and_return(true)
     end
 
     it "should call create_env if the key does not exist" do
@@ -94,15 +94,15 @@ describe Chef::Provider::Env do
 
     it "should call modify_env if the key exists and values are not equal" do
       @provider.key_exists = true
-      @provider.stub!(:compare_value).and_return(true)
+      @provider.stub(:compare_value).and_return(true)
       @provider.should_receive(:modify_env).and_return(true)
       @provider.action_create
     end
 
     it "should set the new_resources updated flag when it updates an existing value" do
       @provider.key_exists = true
-      @provider.stub!(:compare_value).and_return(true)
-      @provider.stub!(:modify_env).and_return(true)
+      @provider.stub(:compare_value).and_return(true)
+      @provider.stub(:modify_env).and_return(true)
       @provider.action_create
       @new_resource.should be_updated
     end
@@ -112,8 +112,8 @@ describe Chef::Provider::Env do
     before(:each) do
       @provider.current_resource = @current_resource
       @provider.key_exists = false
-      @provider.stub!(:delete_element).and_return(false)
-      @provider.stub!(:delete_env).and_return(true)
+      @provider.stub(:delete_element).and_return(false)
+      @provider.stub(:delete_env).and_return(true)
     end
 
     it "should not call delete_env if the key does not exist" do
@@ -143,7 +143,7 @@ describe Chef::Provider::Env do
     before(:each) do
       @provider.current_resource = @current_resource
       @provider.key_exists = true
-      @provider.stub!(:modify_env).and_return(true)
+      @provider.stub(:modify_env).and_return(true)
     end
 
     it "should call modify_group if the key exists and values are not equal" do
@@ -153,8 +153,8 @@ describe Chef::Provider::Env do
     end
 
     it "should set the new resources updated flag to true if modify_env is called" do
-      @provider.stub!(:compare_value).and_return(true)
-      @provider.stub!(:modify_env).and_return(true)
+      @provider.stub(:compare_value).and_return(true)
+      @provider.stub(:modify_env).and_return(true)
       @provider.action_modify
       @new_resource.should be_updated
     end
@@ -183,12 +183,12 @@ describe Chef::Provider::Env do
     end
 
     it "should return true if the element is not found" do
-      @new_resource.stub!(:value).and_return("C:/baz/bin")
+      @new_resource.stub(:value).and_return("C:/baz/bin")
       @provider.delete_element.should eql(true)
     end
 
     it "should return false if the delim not defined" do
-      @new_resource.stub!(:delim).and_return(nil)
+      @new_resource.stub(:delim).and_return(nil)
       @provider.delete_element.should eql(false)
     end
 

data/spec/unit/provider/erl_call_spec.rb

@@ -31,7 +31,7 @@ describe Chef::Provider::ErlCall do
 
     @provider = Chef::Provider::ErlCall.new(@new_resource, @run_context)
 
-    @provider.stub!(:popen4).and_return(@status)
+    @provider.stub(:popen4).and_return(@status)
     @stdin = StringIO.new
     @stdout = StringIO.new('{ok, woohoo}')
     @stderr = StringIO.new

data/spec/unit/provider/execute_spec.rb

@@ -33,12 +33,12 @@ describe Chef::Provider::Execute do
     @provider.current_resource = @current_resource
     Chef::Log.level = :info
     # FIXME: There should be a test for how STDOUT.tty? changes the live_stream option being passed
-    STDOUT.stub!(:tty?).and_return(true)
+    STDOUT.stub(:tty?).and_return(true)
   end
 
 
   it "should execute foo_resource" do
-    @provider.stub!(:load_current_resource)
+    @provider.stub(:load_current_resource)
     opts = {}
     opts[:timeout] = @new_resource.timeout
     opts[:returns] = @new_resource.returns
@@ -53,7 +53,7 @@ describe Chef::Provider::Execute do
   end
 
   it "should do nothing if the sentinel file exists" do
-    @provider.stub!(:load_current_resource)
+    @provider.stub(:load_current_resource)
     File.should_receive(:exists?).with(@new_resource.creates).and_return(true)
     @provider.should_not_receive(:shell_out!)
     Chef::Log.should_not_receive(:warn)
@@ -65,7 +65,7 @@ describe Chef::Provider::Execute do
   it "should respect cwd options for 'creates'" do
     @new_resource.cwd "/tmp"
     @new_resource.creates "foo_resource"
-    @provider.stub!(:load_current_resource)
+    @provider.stub(:load_current_resource)
     File.should_receive(:exists?).with(@new_resource.creates).and_return(false)
     File.should_receive(:exists?).with(File.join("/tmp", @new_resource.creates)).and_return(true)
     Chef::Log.should_not_receive(:warn)
@@ -77,7 +77,7 @@ describe Chef::Provider::Execute do
 
   it "should warn if user specified relative path without cwd" do
     @new_resource.creates "foo_resource"
-    @provider.stub!(:load_current_resource)
+    @provider.stub(:load_current_resource)
     Chef::Log.should_receive(:warn).with(/relative path/)
     File.should_receive(:exists?).with(@new_resource.creates).and_return(true)
     @provider.should_not_receive(:shell_out!)

data/spec/unit/provider/file/content_spec.rb

@@ -25,7 +25,7 @@ describe Chef::Provider::File::Content do
   #
 
   let(:current_resource) do
-    mock("Chef::Provider::File::Resource (current)")
+    double("Chef::Provider::File::Resource (current)")
   end
 
   let(:enclosing_directory) {
@@ -36,11 +36,11 @@ describe Chef::Provider::File::Content do
   }
 
   let(:new_resource) do
-    mock("Chef::Provider::File::Resource (new)", :name => "seattle.txt", :path => resource_path)
+    double("Chef::Provider::File::Resource (new)", :name => "seattle.txt", :path => resource_path)
   end
 
   let(:run_context) do
-    mock("Chef::RunContext")
+    double("Chef::RunContext")
   end
 
   #
@@ -53,7 +53,7 @@ describe Chef::Provider::File::Content do
   describe "when the resource has a content attribute set" do
 
     before do
-      new_resource.stub!(:content).and_return("Do do do do, do do do do, do do do do, do do do do")
+      new_resource.stub(:content).and_return("Do do do do, do do do do, do do do do, do do do do")
     end
 
     it "returns a tempfile" do
@@ -81,7 +81,7 @@ describe Chef::Provider::File::Content do
   describe "when the resource does not have a content attribute set" do
 
     before do
-      new_resource.stub!(:content).and_return(nil)
+      new_resource.stub(:content).and_return(nil)
     end
 
     it "should return nil instead of a tempfile" do

data/spec/unit/provider/file_spec.rb

@@ -29,7 +29,7 @@ describe Chef::Provider::File do
   end
 
   let(:content) do
-    content = mock('Chef::Provider::File::Content')
+    content = double('Chef::Provider::File::Content')
   end
 
   let(:node) { double('Chef::Node') }

data/spec/unit/provider/git_spec.rb

@@ -21,7 +21,7 @@ require 'spec_helper'
 describe Chef::Provider::Git do
 
   before(:each) do
-    STDOUT.stub!(:tty?).and_return(true)
+    STDOUT.stub(:tty?).and_return(true)
     Chef::Log.level = :info
 
     @current_resource = Chef::Resource::Git.new("web2.0 app")
@@ -41,9 +41,9 @@ describe Chef::Provider::Git do
   context "determining the revision of the currently deployed checkout" do
 
     before do
-      @stdout = mock("standard out")
-      @stderr = mock("standard error")
-      @exitstatus = mock("exitstatus")
+      @stdout = double("standard out")
+      @stderr = double("standard error")
+      @exitstatus = double("exitstatus")
     end
 
     it "sets the current revision to nil if the deploy dir does not exist" do
@@ -54,7 +54,7 @@ describe Chef::Provider::Git do
     it "determines the current revision when there is one" do
       ::File.should_receive(:exist?).with("/my/deploy/dir/.git").and_return(true)
       @stdout = "9b4d8dc38dd471246e7cfb1c3c1ad14b0f2bee13\n"
-      @provider.should_receive(:shell_out!).with('git rev-parse HEAD', {:cwd => '/my/deploy/dir', :returns => [0,128]}).and_return(mock("ShellOut result", :stdout => @stdout))
+      @provider.should_receive(:shell_out!).with('git rev-parse HEAD', {:cwd => '/my/deploy/dir', :returns => [0,128]}).and_return(double("ShellOut result", :stdout => @stdout))
       @provider.find_current_revision.should eql("9b4d8dc38dd471246e7cfb1c3c1ad14b0f2bee13")
     end
 
@@ -62,13 +62,13 @@ describe Chef::Provider::Git do
       ::File.should_receive(:exist?).with("/my/deploy/dir/.git").and_return(true)
       @stderr = "fatal: Not a git repository (or any of the parent directories): .git"
       @stdout = ""
-      @provider.should_receive(:shell_out!).with('git rev-parse HEAD', :cwd => '/my/deploy/dir', :returns => [0,128]).and_return(mock("ShellOut result", :stdout => "", :stderr => @stderr))
+      @provider.should_receive(:shell_out!).with('git rev-parse HEAD', :cwd => '/my/deploy/dir', :returns => [0,128]).and_return(double("ShellOut result", :stdout => "", :stderr => @stderr))
       @provider.find_current_revision.should be_nil
     end
   end
 
   it "creates a current_resource with the currently deployed revision when a clone exists in the destination dir" do
-    @provider.stub!(:find_current_revision).and_return("681c9802d1c62a45b490786c18f0b8216b309440")
+    @provider.stub(:find_current_revision).and_return("681c9802d1c62a45b490786c18f0b8216b309440")
     @provider.load_current_resource
     @provider.current_resource.name.should eql(@resource.name)
     @provider.current_resource.revision.should eql("681c9802d1c62a45b490786c18f0b8216b309440")
@@ -93,7 +93,7 @@ describe Chef::Provider::Git do
       @resource.revision "v1.0"
       @stdout = ("d03c22a5e41f5ae3193460cca044ed1435029f53\trefs/heads/0.8-alpha\n" +
                  "503c22a5e41f5ae3193460cca044ed1435029f53\trefs/heads/v1.0\n")
-      @provider.should_receive(:shell_out!).with(@git_ls_remote + "v1.0*", {:log_tag=>"git[web2.0 app]"}).and_return(mock("ShellOut result", :stdout => @stdout))
+      @provider.should_receive(:shell_out!).with(@git_ls_remote + "v1.0*", {:log_tag=>"git[web2.0 app]"}).and_return(double("ShellOut result", :stdout => @stdout))
       @provider.target_revision.should eql("503c22a5e41f5ae3193460cca044ed1435029f53")
     end
 
@@ -102,7 +102,7 @@ describe Chef::Provider::Git do
       @stdout = ("d03c22a5e41f5ae3193460cca044ed1435029f53\trefs/heads/0.8-alpha\n" +
                  "503c22a5e41f5ae3193460cca044ed1435029f53\trefs/heads/v1.0\n" +
                  "663c22a5e41f5ae3193460cca044ed1435029f53\trefs/heads/v1.0^{}\n")
-      @provider.should_receive(:shell_out!).with(@git_ls_remote + "v1.0*", {:log_tag=>"git[web2.0 app]"}).and_return(mock("ShellOut result", :stdout => @stdout))
+      @provider.should_receive(:shell_out!).with(@git_ls_remote + "v1.0*", {:log_tag=>"git[web2.0 app]"}).and_return(double("ShellOut result", :stdout => @stdout))
       @provider.target_revision.should eql("663c22a5e41f5ae3193460cca044ed1435029f53")
     end
 
@@ -110,32 +110,32 @@ describe Chef::Provider::Git do
       @resource.revision "origin/"
       @provider.action = :checkout
       @provider.define_resource_requirements
-      ::File.stub!(:directory?).with("/my/deploy").and_return(true)
+      ::File.stub(:directory?).with("/my/deploy").and_return(true)
       lambda {@provider.process_resource_requirements}.should raise_error(Chef::Exceptions::InvalidRemoteGitReference)
     end
 
     it "raises an unresolvable git reference error if the revision can't be resolved to any revision and assertions are run" do
       @resource.revision "FAIL, that's the revision I want"
       @provider.action = :checkout
-      @provider.should_receive(:shell_out!).and_return(mock("ShellOut result", :stdout => "\n"))
+      @provider.should_receive(:shell_out!).and_return(double("ShellOut result", :stdout => "\n"))
       @provider.define_resource_requirements
       lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::UnresolvableGitReference)
     end
 
     it "does not raise an error if the revision can't be resolved when assertions are not run" do
       @resource.revision "FAIL, that's the revision I want"
-      @provider.should_receive(:shell_out!).and_return(mock("ShellOut result", :stdout => "\n"))
+      @provider.should_receive(:shell_out!).and_return(double("ShellOut result", :stdout => "\n"))
       @provider.target_revision.should == nil
     end
 
     it "does not raise an error when the revision is valid and assertions are run." do
       @resource.revision "0.8-alpha"
       @stdout = "503c22a5e41f5ae3193460cca044ed1435029f53\trefs/heads/0.8-alpha\n"
-      @provider.should_receive(:shell_out!).with(@git_ls_remote + "0.8-alpha*", {:log_tag=>"git[web2.0 app]"}).and_return(mock("ShellOut result", :stdout => @stdout))
+      @provider.should_receive(:shell_out!).with(@git_ls_remote + "0.8-alpha*", {:log_tag=>"git[web2.0 app]"}).and_return(double("ShellOut result", :stdout => @stdout))
       @provider.action = :checkout
-      ::File.stub!(:directory?).with("/my/deploy").and_return(true)
+      ::File.stub(:directory?).with("/my/deploy").and_return(true)
       @provider.define_resource_requirements
-      lambda { @provider.process_resource_requirements }.should_not raise_error(RuntimeError)
+      lambda { @provider.process_resource_requirements }.should_not raise_error
     end
 
     it "gives the latest HEAD revision SHA if nothing is specified" do
@@ -156,7 +156,7 @@ b7d19519a1c15f1c1a324e2683bd728b6198ce5a\trefs/tags/0.7.8^{}
 ebc1b392fe7e8f0fbabc305c299b4d365d2b4d9b\trefs/tags/chef-server-package
 SHAS
       @resource.revision ''
-      @provider.should_receive(:shell_out!).with(@git_ls_remote + "HEAD", {:log_tag=>"git[web2.0 app]"}).and_return(mock("ShellOut result", :stdout => @stdout))
+      @provider.should_receive(:shell_out!).with(@git_ls_remote + "HEAD", {:log_tag=>"git[web2.0 app]"}).and_return(double("ShellOut result", :stdout => @stdout))
       @provider.target_revision.should eql("28af684d8460ba4793eda3e7ac238c864a5d029a")
     end
   end
@@ -179,7 +179,7 @@ SHAS
     before do
       @resource.user deploy_user
       @resource.ssh_wrapper wrapper
-      Etc.stub!(:getpwnam).and_return(double("Struct::Passwd", :name => @resource.user, :dir => "/home/deployNinja"))
+      Etc.stub(:getpwnam).and_return(double("Struct::Passwd", :name => @resource.user, :dir => "/home/deployNinja"))
     end
     context "without a timeout set" do
       it "clones a repo with default git options" do
@@ -199,7 +199,7 @@ SHAS
 
   it "runs a clone command with escaped destination" do
     @resource.user "deployNinja"
-    Etc.stub!(:getpwnam).and_return(double("Struct::Passwd", :name => @resource.user, :dir => "/home/deployNinja"))
+    Etc.stub(:getpwnam).and_return(double("Struct::Passwd", :name => @resource.user, :dir => "/home/deployNinja"))
     @resource.destination "/Application Support/with/space"
     @resource.ssh_wrapper "do_it_this_way.sh"
     expected_cmd = "git clone  \"git://github.com/opscode/chef.git\" \"/Application Support/with/space\""
@@ -255,7 +255,7 @@ SHAS
 
   it "runs a sync command with the user and group specified in the resource" do
     @resource.user("whois")
-    Etc.stub!(:getpwnam).and_return(double("Struct::Passwd", :name => @resource.user, :dir => "/home/whois"))
+    Etc.stub(:getpwnam).and_return(double("Struct::Passwd", :name => @resource.user, :dir => "/home/whois"))
     @resource.group("thisis")
     @provider.should_receive(:setup_remote_tracking_branches).with(@resource.remote, @resource.repository)
     expected_cmd = "git fetch origin && git fetch origin --tags && git reset --hard d35af14d41ae22b19da05d7d03a0bafc321b244c"
@@ -302,7 +302,7 @@ SHAS
     it "runs the config with the user and group specified in the resource" do
       @resource.user("whois")
       @resource.group("thisis")
-      Etc.stub!(:getpwnam).and_return(double("Struct::Passwd", :name => @resource.user, :dir => "/home/whois"))
+      Etc.stub(:getpwnam).and_return(double("Struct::Passwd", :name => @resource.user, :dir => "/home/whois"))
       command_response = double('shell_out')
       command_response.stub(:exitstatus) { 1 }
       expected_command = "git config --get remote.#{@resource.remote}.url"
@@ -391,17 +391,17 @@ SHAS
   end
 
   it "raises an error if the git clone command would fail because the enclosing directory doesn't exist" do
-    @provider.stub!(:shell_out!)
+    @provider.stub(:shell_out!)
     lambda {@provider.run_action(:sync)}.should raise_error(Chef::Exceptions::MissingParentDirectory)
   end
 
   it "does a checkout by cloning the repo and then enabling submodules" do
     # will be invoked in load_current_resource
-    ::File.stub!(:exist?).with("/my/deploy/dir/.git").and_return(false)
+    ::File.stub(:exist?).with("/my/deploy/dir/.git").and_return(false)
 
-    ::File.stub!(:exist?).with("/my/deploy/dir").and_return(true)
-    ::File.stub!(:directory?).with("/my/deploy").and_return(true)
-    ::Dir.stub!(:entries).with("/my/deploy/dir").and_return(['.','..'])
+    ::File.stub(:exist?).with("/my/deploy/dir").and_return(true)
+    ::File.stub(:directory?).with("/my/deploy").and_return(true)
+    ::Dir.stub(:entries).with("/my/deploy/dir").and_return(['.','..'])
     @provider.should_receive(:clone)
     @provider.should_receive(:checkout)
     @provider.should_receive(:enable_submodules)
@@ -413,11 +413,11 @@ SHAS
 
   it "does not call checkout if enable_checkout is false" do
     # will be invoked in load_current_resource
-    ::File.stub!(:exist?).with("/my/deploy/dir/.git").and_return(false)
+    ::File.stub(:exist?).with("/my/deploy/dir/.git").and_return(false)
 
-    ::File.stub!(:exist?).with("/my/deploy/dir").and_return(true)
-    ::File.stub!(:directory?).with("/my/deploy").and_return(true)
-    ::Dir.stub!(:entries).with("/my/deploy/dir").and_return(['.','..'])
+    ::File.stub(:exist?).with("/my/deploy/dir").and_return(true)
+    ::File.stub(:directory?).with("/my/deploy").and_return(true)
+    ::Dir.stub(:entries).with("/my/deploy/dir").and_return(['.','..'])
 
     @resource.enable_checkout false
     @provider.should_receive(:clone)
@@ -429,10 +429,10 @@ SHAS
   # REGRESSION TEST: on some OSes, the entries from an empty directory will be listed as
   # ['..', '.'] but this shouldn't change the behavior
   it "does a checkout by cloning the repo and then enabling submodules when the directory entries are listed as %w{.. .}" do
-    ::File.stub!(:exist?).with("/my/deploy/dir/.git").and_return(false)
-    ::File.stub!(:exist?).with("/my/deploy/dir").and_return(false)
-    ::File.stub!(:directory?).with("/my/deploy").and_return(true)
-    ::Dir.stub!(:entries).with("/my/deploy/dir").and_return(['..','.'])
+    ::File.stub(:exist?).with("/my/deploy/dir/.git").and_return(false)
+    ::File.stub(:exist?).with("/my/deploy/dir").and_return(false)
+    ::File.stub(:directory?).with("/my/deploy").and_return(true)
+    ::Dir.stub(:entries).with("/my/deploy/dir").and_return(['..','.'])
     @provider.should_receive(:clone)
     @provider.should_receive(:checkout)
     @provider.should_receive(:enable_submodules)
@@ -443,11 +443,11 @@ SHAS
 
   it "should not checkout if the destination exists or is a non empty directory" do
     # will be invoked in load_current_resource
-    ::File.stub!(:exist?).with("/my/deploy/dir/.git").and_return(false)
+    ::File.stub(:exist?).with("/my/deploy/dir/.git").and_return(false)
 
-    ::File.stub!(:exist?).with("/my/deploy/dir").and_return(true)
-    ::File.stub!(:directory?).with("/my/deploy").and_return(true)
-    ::Dir.stub!(:entries).with("/my/deploy/dir").and_return(['.','..','foo','bar'])
+    ::File.stub(:exist?).with("/my/deploy/dir").and_return(true)
+    ::File.stub(:directory?).with("/my/deploy").and_return(true)
+    ::Dir.stub(:entries).with("/my/deploy/dir").and_return(['.','..','foo','bar'])
     @provider.should_not_receive(:clone)
     @provider.should_not_receive(:checkout)
     @provider.should_not_receive(:enable_submodules)
@@ -458,7 +458,7 @@ SHAS
 
   it "syncs the code by updating the source when the repo has already been checked out" do
     ::File.should_receive(:exist?).with("/my/deploy/dir/.git").and_return(true)
-    ::File.stub!(:directory?).with("/my/deploy").and_return(true)
+    ::File.stub(:directory?).with("/my/deploy").and_return(true)
     @provider.should_receive(:find_current_revision).exactly(2).and_return('d35af14d41ae22b19da05d7d03a0bafc321b244c')
     @provider.should_not_receive(:fetch_updates)
     @provider.should_receive(:add_remotes)
@@ -468,10 +468,10 @@ SHAS
 
   it "marks the resource as updated when the repo is updated and gets a new version" do
     ::File.should_receive(:exist?).with("/my/deploy/dir/.git").and_return(true)
-    ::File.stub!(:directory?).with("/my/deploy").and_return(true)
+    ::File.stub(:directory?).with("/my/deploy").and_return(true)
     # invoked twice - first time from load_current_resource
     @provider.should_receive(:find_current_revision).exactly(2).and_return('d35af14d41ae22b19da05d7d03a0bafc321b244c')
-    @provider.stub!(:target_revision).and_return('28af684d8460ba4793eda3e7ac238c864a5d029a')
+    @provider.stub(:target_revision).and_return('28af684d8460ba4793eda3e7ac238c864a5d029a')
     @provider.should_receive(:fetch_updates)
     @provider.should_receive(:enable_submodules)
     @provider.should_receive(:add_remotes)
@@ -481,9 +481,9 @@ SHAS
 
   it "does not fetch any updates if the remote revision matches the current revision" do
     ::File.should_receive(:exist?).with("/my/deploy/dir/.git").and_return(true)
-    ::File.stub!(:directory?).with("/my/deploy").and_return(true)
-    @provider.stub!(:find_current_revision).and_return('d35af14d41ae22b19da05d7d03a0bafc321b244c')
-    @provider.stub!(:target_revision).and_return('d35af14d41ae22b19da05d7d03a0bafc321b244c')
+    ::File.stub(:directory?).with("/my/deploy").and_return(true)
+    @provider.stub(:find_current_revision).and_return('d35af14d41ae22b19da05d7d03a0bafc321b244c')
+    @provider.stub(:target_revision).and_return('d35af14d41ae22b19da05d7d03a0bafc321b244c')
     @provider.should_not_receive(:fetch_updates)
     @provider.should_receive(:add_remotes)
     @provider.run_action(:sync)
@@ -491,7 +491,7 @@ SHAS
   end
 
   it "clones the repo instead of fetching it if the deploy directory doesn't exist" do
-    ::File.stub!(:directory?).with("/my/deploy").and_return(true)
+    ::File.stub(:directory?).with("/my/deploy").and_return(true)
     ::File.should_receive(:exist?).with("/my/deploy/dir/.git").exactly(2).and_return(false)
     @provider.should_receive(:action_checkout)
     @provider.should_not_receive(:shell_out!)
@@ -501,9 +501,9 @@ SHAS
 
   it "clones the repo instead of fetching updates if the deploy directory is empty" do
     ::File.should_receive(:exist?).with("/my/deploy/dir/.git").exactly(2).and_return(false)
-    ::File.stub!(:directory?).with("/my/deploy").and_return(true)
-    ::File.stub!(:directory?).with("/my/deploy/dir").and_return(true)
-    @provider.stub!(:sync_command).and_return("huzzah!")
+    ::File.stub(:directory?).with("/my/deploy").and_return(true)
+    ::File.stub(:directory?).with("/my/deploy/dir").and_return(true)
+    @provider.stub(:sync_command).and_return("huzzah!")
     @provider.should_receive(:action_checkout)
     @provider.should_not_receive(:shell_out!).with("huzzah!", :cwd => "/my/deploy/dir")
     @provider.run_action(:sync)