whiskey_disk 0.6.22 → 0.6.23

data/spec/whiskey_disk/helpers_spec.rb

@@ -2,40 +2,40 @@ require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper.rb
 require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'lib', 'whiskey_disk', 'helpers'))
 
 describe 'when checking for a role during setup or deployment' do
-  it 'should accept a role string' do
+  it 'accepts a role string' do
     lambda { role?('web') }.should.not.raise(ArgumentError)
   end
   
-  it 'should require a role string' do
+  it 'requires a role string' do
     lambda { role? }.should.raise(ArgumentError)
   end
 
-  it 'should return false if the WD_ROLES environment variable is unset' do
+  it 'returns false if the WD_ROLES environment variable is unset' do
     ENV['WD_ROLES'] = nil
     role?(:web).should.be.false
   end
 
-  it 'should return false if the WD_ROLES environment variable is empty' do
+  it 'returns false if the WD_ROLES environment variable is empty' do
     ENV['WD_ROLES'] = ''
     role?(:web).should.be.false
   end
   
-  it 'should return true if the role, as a symbol is among the roles in the WD_ROLES env variable' do
+  it 'returns true if the role, as a symbol is among the roles in the WD_ROLES env variable' do
     ENV['WD_ROLES'] = 'db:web'
     role?(:db).should.be.true
   end
   
-  it 'should return true if the role, as a string is among the roles in the WD_ROLES env variable' do
+  it 'returns true if the role, as a string is among the roles in the WD_ROLES env variable' do
     ENV['WD_ROLES'] = 'db:web'
     role?('db').should.be.true
   end
   
-  it 'should return false if the role, as a symbol is not among the roles in the WD_ROLES env variable' do
+  it 'returns false if the role, as a symbol is not among the roles in the WD_ROLES env variable' do
     ENV['WD_ROLES'] = 'db:web'
     role?(:app).should.be.false
   end
   
-  it 'should return false if the role, as a string is not among the roles in the WD_ROLES env variable' do
+  it 'returns false if the role, as a string is not among the roles in the WD_ROLES env variable' do
     ENV['WD_ROLES'] = 'db:web'
     role?('app').should.be.false
   end
@@ -61,70 +61,70 @@ describe 'when determining if certain files changed when a deployment was run' d
     set_rsync_changes([])
   end
   
-  it 'should accept a path' do
+  it 'accepts a path' do
     lambda { changed?('foo') }.should.not.raise(ArgumentError)
   end
   
-  it 'should require a path' do
+  it 'requires a path' do
     lambda { changed? }.should.raise(ArgumentError)
   end
   
-  it 'should be true when the specified file is in the list of git changes' do
+  it 'returns true when the specified file is in the list of git changes' do
     set_git_changes([ @matching_file, @random_file])
     changed?(@matching_file).should.be.true
   end
   
-  it 'should ignore trailing "/"s in the provided path when doing an exact git change match' do
+  it 'ignores trailing "/"s in the provided path when doing an exact git change match' do
     set_git_changes([ @matching_file, @random_file])
     changed?(@matching_file + '///').should.be.true    
   end
   
-  it 'should be true when the specified path is a full path prefix in the list of git changes' do
+  it 'returns true when the specified path is a full path prefix in the list of git changes' do
     set_git_changes([ @matching_file , @random_file])
     changed?(@matching_path).should.be.true    
   end
   
-  it 'should ignore trailing "/"s in the provided path when doing a path git change match' do
+  it 'ignores trailing "/"s in the provided path when doing a path git change match' do
     set_git_changes([ @matching_file , @random_file])
     changed?(@matching_path + '///').should.be.true    
   end
 
-  it 'should be true when the specified file is in the list of rsync changes' do    
+  it 'returns true when the specified file is in the list of rsync changes' do    
     set_rsync_changes([ @matching_file, @random_file])
     changed?(@matching_file).should.be.true
   end
 
-  it 'should ignore trailing "/"s in the provided path when doing an exact rsync change match' do
+  it 'ignores trailing "/"s in the provided path when doing an exact rsync change match' do
     set_rsync_changes([ @matching_file, @random_file])
     changed?(@matching_file + "///").should.be.true
   end
 
-  it 'should be true when the specified path is a full path prefix in the list of git changes' do
+  it 'returnes true when the specified path is a full path prefix in the list of git changes' do
     set_rsync_changes([ @matching_file , @random_file])
     changed?(@matching_path).should.be.true    
   end
   
-  it 'should ignore trailing "/"s in the provided path when doing a path rsync change match' do
+  it 'ignores trailing "/"s in the provided path when doing a path rsync change match' do
     set_rsync_changes([ @matching_file , @random_file])
     changed?(@matching_path + '///').should.be.true    
   end
   
-  it 'should ignore regex metacharacters when looking for a git match' do
+  it 'ignores regex metacharacters when looking for a git match' do
     set_git_changes([ '/path/to/somestring'])
     changed?('/path/to/some.*').should.be.false
   end
   
-  it 'should ignore regex metacharacters when looking for an rsync match' do
+  it 'ignores regex metacharacters when looking for an rsync match' do
     set_rsync_changes([ '/path/to/somestring'])
     changed?('/path/to/some.*').should.be.false
   end
   
-  it 'should be true when the git changes file cannot be found' do
+  it 'returns true when the git changes file cannot be found' do
     set_git_changes(nil)
     changed?(@matching_file).should.be.true    
   end
   
-  it 'should be false if not path or file matches the specified file' do
+  it 'returns false if not path or file matches the specified file' do
     set_git_changes([@matching_file, @matching_path, @random_file, @substring_file])
     set_rsync_changes([@matching_file, @matching_path, @random_file, @substring_file])
     changed?(@non_matching_file).should.be.false
@@ -156,30 +156,30 @@ whiskey_disk.gemspec
 '   
   end
     
-  it 'should work without arguments' do
+  it 'works without arguments' do
     lambda { git_changes }.should.not.raise(ArgumentError)
   end
   
-  it 'should not allow arguments' do
+  it 'does not allow arguments' do
     lambda { git_changes(:foo) }.should.raise(ArgumentError)
   end
   
-  it 'should return nil when a git changes file cannot be found' do
+  it 'returns nil when a git changes file cannot be found' do
     self.stub!(:read_git_changes_file).and_raise
     git_changes.should.be.nil
   end
   
-  it 'should return an empty list if no files are found in the git changes file' do
+  it 'returns an empty list if no files are found in the git changes file' do
     self.stub!(:read_git_changes_file).and_return('')
     git_changes.should == []
   end
   
-  it 'should return a list of all filenames mentioned in the git changes file' do
+  it 'returns a list of all filenames mentioned in the git changes file' do
     self.stub!(:read_git_changes_file).and_return(@contents)
     git_changes.should == @contents.split("\n")
   end
   
-  it 'should strip duplicates from filenames mentioned in the git changes file' do
+  it 'strips duplicates from filenames mentioned in the git changes file' do
     lines = @contents.split("\n")
     duplicates = @contents + lines.first + "\n" + lines.last + "\n"
     self.stub!(:read_git_changes_file).and_return(duplicates)
@@ -298,25 +298,25 @@ describe "when finding files changed by rsync in a deployment" do
       ]
   end
 
-  it 'should work without arguments' do
+  it 'works without arguments' do
     lambda { rsync_changes }.should.not.raise(ArgumentError)
   end
 
-  it 'should not allow arguments' do
+  it 'does not allow arguments' do
     lambda { rsync_changes(:foo) }.should.raise(ArgumentError)
   end
 
-  it 'should return nil when an rsync changes file cannot be found' do
+  it 'returns nil when an rsync changes file cannot be found' do
     self.stub!(:read_rsync_changes_file).and_raise
     rsync_changes.should.be.nil
   end
 
-  it 'should return an empty list if no files are found in the rsync changes file' do
+  it 'returns an empty list if no files are found in the rsync changes file' do
     self.stub!(:read_rsync_changes_file).and_return('')
     rsync_changes.should == []
   end
 
-  it 'should return a list of all changed filenames mentioned in the rsync changes file, excluding "."' do
+  it 'returns a list of all changed filenames mentioned in the rsync changes file, excluding "."' do
     self.stub!(:read_rsync_changes_file).and_return(@contents)
     rsync_changes.sort.first.should == @changes.sort.first
   end
@@ -330,15 +330,15 @@ describe 'when reading the git-related changes for a deployment' do
     File.stub!(:read).with(@changes_path).and_return(@contents)
   end
   
-  it 'should work without arguments' do
+  it 'works without arguments' do
     lambda { read_git_changes_file }.should.not.raise(ArgumentError)
   end
   
-  it 'should not allow arguments' do
+  it 'does not allow arguments' do
     lambda { read_git_changes_file(:foo) }.should.raise(ArgumentError)
   end
   
-  it 'should read the git changes file' do
+  it 'reads the git changes file' do
     File.should.receive(:read) do |arg|
       arg.should == @changes_path
       @contents
@@ -346,11 +346,11 @@ describe 'when reading the git-related changes for a deployment' do
     read_git_changes_file
   end
   
-  it 'should return the contents of the git changes file' do
+  it 'returns the contents of the git changes file' do
     read_git_changes_file.should == @contents
   end
   
-  it 'should fail if the git changes file cannot be read' do
+  it 'fails if the git changes file cannot be read' do
     File.stub!(:read).with(@changes_path).and_raise(Errno::ENOENT)
     lambda { read_git_changes_file }.should.raise(Errno::ENOENT)
   end
@@ -364,15 +364,15 @@ describe 'when reading the rsync-related changes for a deployment' do
     File.stub!(:read).with(@changes_path).and_return(@contents)
   end
   
-  it 'should work without arguments' do
+  it 'works without arguments' do
     lambda { read_rsync_changes_file }.should.not.raise(ArgumentError)
   end
   
-  it 'should not allow arguments' do
+  it 'does not allow arguments' do
     lambda { read_rsync_changes_file(:foo) }.should.raise(ArgumentError)
   end
   
-  it 'should read the rsync changes file' do
+  it 'reads the rsync changes file' do
     File.should.receive(:read) do |arg|
       arg.should == @changes_path
       @contents
@@ -380,11 +380,11 @@ describe 'when reading the rsync-related changes for a deployment' do
     read_rsync_changes_file
   end
   
-  it 'should return the contents of the rsync changes file' do
+  it 'returns the contents of the rsync changes file' do
     read_rsync_changes_file.should == @contents
   end
   
-  it 'should fail if the rsync changes file cannot be read' do
+  it 'fails if the rsync changes file cannot be read' do
     File.stub!(:read).with(@changes_path).and_raise(Errno::ENOENT)
     lambda { read_rsync_changes_file }.should.raise(Errno::ENOENT)
   end
@@ -398,19 +398,19 @@ describe 'computing the path to the git changes file' do
     @io_handle.stub!(:read).and_return(@git_path + "\n")
   end
   
-  it 'should work without arguments' do
+  it 'works without arguments' do
     lambda { git_changes_path }.should.not.raise(ArgumentError)
   end
   
-  it 'should not allow arguments' do
+  it 'does not allow arguments' do
     lambda { git_changes_path(:foo) }.should.raise(ArgumentError)
   end
   
-  it 'should return the path to the .whiskey_disk_git_changes file in the git top-level path' do
+  it 'returns the path to the .whiskey_disk_git_changes file in the git top-level path' do
     git_changes_path.should == File.join(@git_path, '.whiskey_disk_git_changes')
   end
   
-  it 'should return the path to the .whiskey_disk_git_changes file in the current directory of the git top-level cannot be found' do
+  it 'returns the path to the .whiskey_disk_git_changes file in the current directory of the git top-level cannot be found' do
     @io_handle.stub!(:read).and_return('')
     git_changes_path.should == File.join(Dir.pwd, '.whiskey_disk_git_changes')    
   end
@@ -424,19 +424,19 @@ describe 'computing the path to the rsync changes file' do
     @io_handle.stub!(:read).and_return(@rsync_path + "\n")
   end
   
-  it 'should work without arguments' do
+  it 'works without arguments' do
     lambda { rsync_changes_path }.should.not.raise(ArgumentError)
   end
   
-  it 'should not allow arguments' do
+  it 'does not allow arguments' do
     lambda { rsync_changes_path(:foo) }.should.raise(ArgumentError)
   end
   
-  it 'should return the path to the .whiskey_disk_rsync_changes file in the git top-level path' do
+  it 'returns the path to the .whiskey_disk_rsync_changes file in the git top-level path' do
     rsync_changes_path.should == File.join(@rsync_path, '.whiskey_disk_rsync_changes')
   end
   
-  it 'should return the path to the .whiskey_disk_rsync_changes file in the current directory of the git top-level cannot be found' do
+  it 'returns the path to the .whiskey_disk_rsync_changes file in the current directory of the git top-level cannot be found' do
     @io_handle.stub!(:read).and_return('')
     rsync_changes_path.should == File.join(Dir.pwd, '.whiskey_disk_rsync_changes')    
   end

data/spec/whiskey_disk/rake_spec.rb

@@ -5,7 +5,8 @@ describe 'rake tasks' do
   before do
     Rake.application = @rake = Rake::Application.new
     load File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'lib', 'whiskey_disk', 'rake.rb'))
-    WhiskeyDisk.reset
+    @whiskey_disk = WhiskeyDisk.new
+    WhiskeyDisk.stub!(:new).and_return(@whiskey_disk)
   end
 
   after do
@@ -14,7 +15,7 @@ describe 'rake tasks' do
   
   describe 'deploy:setup' do
     before do
-      WhiskeyDisk.configuration = {}
+      @whiskey_disk.configuration = {}
       [ 
         :ensure_main_parent_path_is_present, 
         :ensure_config_parent_path_is_present,
@@ -29,122 +30,121 @@ describe 'rake tasks' do
         :flush,
         :summarize
       ].each do |meth| 
-        WhiskeyDisk.stub!(meth)
+        @whiskey_disk.stub!(meth)
       end
 
-      WhiskeyDisk.stub!(:success?).and_return(true)
+      @whiskey_disk.stub!(:success?).and_return(true)
     end
     
-    it 'should ensure that the parent path for the main repository checkout is present' do
-      WhiskeyDisk.should.receive(:ensure_main_parent_path_is_present)
+    it 'ensures that the parent path for the main repository checkout is present' do
+      @whiskey_disk.should.receive(:ensure_main_parent_path_is_present)
       @rake["deploy:setup"].invoke
     end
     
     describe 'when a configuration repo is specified' do
-      it 'should ensure that the parent path for the configuration repository checkout is present' do
-        WhiskeyDisk.configuration = { 'config_repository' => 'foo' }
-        WhiskeyDisk.should.receive(:ensure_config_parent_path_is_present)
+      it 'ensures that the parent path for the configuration repository checkout is present' do
+        @whiskey_disk.configuration = { 'config_repository' => 'foo' }
+        @whiskey_disk.should.receive(:ensure_config_parent_path_is_present)
         @rake["deploy:setup"].invoke    
       end
     end
     
     describe 'when no configuration repo is specified' do
-      it 'should not ensure that the path for the configuration repository checkout is present' do
-        WhiskeyDisk.should.not.receive(:ensure_config_parent_path_is_present)
+      it 'does not ensure that the path for the configuration repository checkout is present' do
+        @whiskey_disk.should.not.receive(:ensure_config_parent_path_is_present)
         @rake["deploy:setup"].invoke        
       end
     end
     
-    it 'should check out the main repository' do
-      WhiskeyDisk.should.receive(:checkout_main_repository)
+    it 'checks out the main repository' do
+      @whiskey_disk.should.receive(:checkout_main_repository)
       @rake["deploy:setup"].invoke
     end
     
     describe 'when a configuration repository is specified' do
-      it 'should check out the configuration repository' do
-        WhiskeyDisk.configuration = { 'config_repository' => 'foo' }
-        WhiskeyDisk.should.receive(:checkout_configuration_repository)
+      it 'checks out the configuration repository' do
+        @whiskey_disk.configuration = { 'config_repository' => 'foo' }
+        @whiskey_disk.should.receive(:checkout_configuration_repository)
         @rake["deploy:setup"].invoke
       end
     end
     
     describe 'when no configuration repository is specified' do
-      it 'should not check out the configuration repository' do
-        WhiskeyDisk.should.not.receive(:checkout_configuration_repository)
+      it 'does not check out the configuration repository' do
+        @whiskey_disk.should.not.receive(:checkout_configuration_repository)
         @rake["deploy:setup"].invoke
       end
     end
     
-    it 'should update the main repository checkout' do
-      WhiskeyDisk.should.receive(:update_main_repository_checkout)
+    it 'updates the main repository checkout' do
+      @whiskey_disk.should.receive(:update_main_repository_checkout)
       @rake["deploy:setup"].invoke
     end
     
     describe 'when a configuration repository is specified' do
-      it 'should update the configuration repository checkout' do
-        WhiskeyDisk.configuration = { 'config_repository' => 'foo' }
-        WhiskeyDisk.should.receive(:update_configuration_repository_checkout)
+      it 'updates the configuration repository checkout' do
+        @whiskey_disk.configuration = { 'config_repository' => 'foo' }
+        @whiskey_disk.should.receive(:update_configuration_repository_checkout)
         @rake["deploy:setup"].invoke
       end
     end
     
-    it 'should clear any tracked git or rsync changes' do
-      WhiskeyDisk.should.receive(:initialize_all_changes)
+    it 'clears any tracked git or rsync changes' do
+      @whiskey_disk.should.receive(:initialize_all_changes)
       @rake["deploy:setup"].invoke
     end
     
     describe 'when no configuration repository is specified' do
-      it 'should update the configuration repository checkout' do
-        WhiskeyDisk.should.not.receive(:update_configuration_repository_checkout)
+      it 'updates the configuration repository checkout' do
+        @whiskey_disk.should.not.receive(:update_configuration_repository_checkout)
         @rake["deploy:setup"].invoke
       end
     end
 
     describe 'when a configuration repository is specified' do      
-      it 'should refresh the configuration' do
-        WhiskeyDisk.configuration = { 'config_repository' => 'foo' }
-        WhiskeyDisk.should.receive(:refresh_configuration)
+      it 'refreshes the configuration' do
+        @whiskey_disk.configuration = { 'config_repository' => 'foo' }
+        @whiskey_disk.should.receive(:refresh_configuration)
         @rake["deploy:setup"].invoke
       end
     end
     
     describe 'when no configuration repository is specified' do      
-      it 'should not refresh the configuration' do
-        WhiskeyDisk.should.not.receive(:refresh_configuration)
+      it 'does not refresh the configuration' do
+        @whiskey_disk.should.not.receive(:refresh_configuration)
         @rake["deploy:setup"].invoke
       end
     end
     
-    it 'should run any post setup hooks' do        
-      WhiskeyDisk.should.receive(:run_post_setup_hooks)
+    it 'runs any post setup hooks' do        
+      @whiskey_disk.should.receive(:run_post_setup_hooks)
       @rake["deploy:setup"].invoke
     end
     
-    it 'should flush WhiskeyDisk changes' do
-      WhiskeyDisk.should.receive(:flush)
+    it 'flushes @whiskey_disk changes' do
+      @whiskey_disk.should.receive(:flush)
       @rake["deploy:setup"].invoke
     end
     
-    it 'should summarize the results of the setup run' do
-      WhiskeyDisk.should.receive(:summarize)
+    it 'summarizes the results of the setup run' do
+      @whiskey_disk.should.receive(:summarize)
       @rake["deploy:setup"].invoke
     end
   
-    it 'should not exit in error if all setup runs were successful' do
+    it 'does not exit in error if all setup runs were successful' do
       lambda { @rake["deploy:setup"].invoke }.should.not.raise(SystemExit)
     end
     
-    it 'should exit in error if some setup run was unsuccessful' do
-      WhiskeyDisk.stub!(:success?).and_return(false)
+    it 'exits in error if some setup run was unsuccessful' do
+      @whiskey_disk.stub!(:success?).and_return(false)
       lambda { @rake["deploy:setup"].invoke }.should.raise(SystemExit)
     end
   end
   
   describe 'deploy:now' do
     before do
-      WhiskeyDisk.configuration = { }
+      @whiskey_disk.configuration = { }
       [ 
-        :enable_staleness_checks,
         :update_main_repository_checkout,
         :update_configuration_repository_checkout,
         :refresh_configuration,
@@ -152,109 +152,109 @@ describe 'rake tasks' do
         :flush, 
         :summarize
       ].each do |meth| 
-        WhiskeyDisk.stub!(meth) 
+        @whiskey_disk.stub!(meth) 
       end
       
-      WhiskeyDisk.stub!(:success?).and_return(true)
+      @whiskey_disk.stub!(:success?).and_return(true)
     end
     
-    it 'should enable staleness checks' do
-      WhiskeyDisk.should.receive(:enable_staleness_checks)
+    it 'enables staleness checks' do
+      WhiskeyDisk.should.receive(:new).with(:staleness_checks => true).and_return(@whiskey_disk)      
       @rake["deploy:now"].invoke
     end
     
-    it 'should update the main repository checkout' do
-      WhiskeyDisk.should.receive(:update_main_repository_checkout)
+    it 'updates the main repository checkout' do
+      @whiskey_disk.should.receive(:update_main_repository_checkout)
       @rake["deploy:now"].invoke
     end
     
     describe 'when a configuration repository is specified' do
-      it 'should update the configuration repository checkout' do
-        WhiskeyDisk.configuration = { 'config_repository' => 'foo' }
-        WhiskeyDisk.should.receive(:update_configuration_repository_checkout)
+      it 'updates the configuration repository checkout' do
+        @whiskey_disk.configuration = { 'config_repository' => 'foo' }
+        @whiskey_disk.should.receive(:update_configuration_repository_checkout)
         @rake["deploy:now"].invoke
       end
     end
     
     describe 'when no configuration repository is specified' do
-      it 'should not update the configuration repository checkout' do
-        WhiskeyDisk.should.not.receive(:update_configuration_repository_checkout)
+      it 'does not update the configuration repository checkout' do
+        @whiskey_disk.should.not.receive(:update_configuration_repository_checkout)
         @rake["deploy:now"].invoke
       end
     end
     
     describe 'when a configuration repository is specified' do
-      it 'should refresh the configuration' do
-        WhiskeyDisk.configuration = { 'config_repository' => 'foo' }
-        WhiskeyDisk.should.receive(:refresh_configuration)
+      it 'refreshes the configuration' do
+        @whiskey_disk.configuration = { 'config_repository' => 'foo' }
+        @whiskey_disk.should.receive(:refresh_configuration)
         @rake["deploy:now"].invoke
       end
     end
     
     describe 'when no configuration repository is specified' do
-      it 'should not refresh the configuration' do
-        WhiskeyDisk.should.not.receive(:refresh_configuration)
+      it 'does not refresh the configuration' do
+        @whiskey_disk.should.not.receive(:refresh_configuration)
         @rake["deploy:now"].invoke
       end
     end
     
-    it 'should run any post deployment hooks' do        
-      WhiskeyDisk.should.receive(:run_post_deploy_hooks)
+    it 'runs any post deployment hooks' do        
+      @whiskey_disk.should.receive(:run_post_deploy_hooks)
       @rake["deploy:now"].invoke
     end
     
-    it 'should flush WhiskeyDisk changes' do
-      WhiskeyDisk.should.receive(:flush)
+    it 'flushes @whiskey_disk changes' do
+      @whiskey_disk.should.receive(:flush)
       @rake["deploy:now"].invoke
     end
     
-    it 'should summarize the results of the deployment run' do
-      WhiskeyDisk.should.receive(:summarize)
+    it 'summarizes the results of the deployment run' do
+      @whiskey_disk.should.receive(:summarize)
       @rake["deploy:now"].invoke
     end
     
-    it 'should not exit in error if all deployment runs were successful' do
+    it 'does not exit in error if all deployment runs were successful' do
       lambda { @rake["deploy:now"].invoke }.should.not.raise(SystemExit)
     end
     
-    it 'should exit in error if some deployment run was unsuccessful' do
-      WhiskeyDisk.stub!(:success?).and_return(false)
+    it 'exits in error if some deployment run was unsuccessful' do
+      @whiskey_disk.stub!(:success?).and_return(false)
       lambda { @rake["deploy:now"].invoke }.should.raise(SystemExit)
     end
   end
       
   describe 'deploy:post_setup' do
-    it 'should run the defined post_setup rake task when a post_setup rake task is defined for this environment' do
-      WhiskeyDisk.configuration = { 'environment' => 'production'}
+    it 'runs the defined post_setup rake task when a post_setup rake task is defined for this environment' do
+      @whiskey_disk.configuration = { 'environment' => 'production'}
 
       task "deploy:production:post_setup" do
-        WhiskeyDisk.fake_method
+        @whiskey_disk.fake_method
       end
 
-      WhiskeyDisk.should.receive(:fake_method)
+      @whiskey_disk.should.receive(:fake_method)
       Rake::Task['deploy:post_setup'].invoke
     end
 
-    it 'should not fail when no post_setup rake task is defined for this environment' do
-      WhiskeyDisk.configuration = { 'environment' => 'staging'}
+    it 'does not fail when no post_setup rake task is defined for this environment' do
+      @whiskey_disk.configuration = { 'environment' => 'staging'}
       lambda { Rake::Task['deploy:post_setup'].invoke }.should.not.raise
     end
   end
   
   describe 'deploy:post_deploy' do
-    it 'should run the defined post_deploy rake task when a post_deploy rake task is defined for this environment' do
-      WhiskeyDisk.configuration = { 'environment' => 'production'}
+    it 'runs the defined post_deploy rake task when a post_deploy rake task is defined for this environment' do
+      @whiskey_disk.configuration = { 'environment' => 'production'}
 
       task "deploy:production:post_deploy" do
-        WhiskeyDisk.fake_method
+        @whiskey_disk.fake_method
       end
 
-      WhiskeyDisk.should.receive(:fake_method)
+      @whiskey_disk.should.receive(:fake_method)
       Rake::Task['deploy:post_deploy'].invoke
     end
 
-    it 'should not fail when no post_deploy rake task is defined for this environment' do
-      WhiskeyDisk.configuration = { 'environment' => 'staging'}
+    it 'does not fail when no post_deploy rake task is defined for this environment' do
+      @whiskey_disk.configuration = { 'environment' => 'staging'}
       lambda { Rake::Task['deploy:post_deploy'].invoke }.should.not.raise
     end
   end