RubyGems - whiskey_disk - Versions diffs - 0.5.3 → 0.5.4 - Mend

whiskey_disk 0.5.3 → 0.5.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

data/Rakefile +1 -1
data/VERSION +1 -1
data/lib/whiskey_disk.rb +2 -0
data/spec/whiskey_disk/config_spec.rb +183 -125
data/spec/whiskey_disk/rake_spec.rb +15 -34
data/spec/whiskey_disk_spec.rb +50 -113
data/whiskey_disk.gemspec +2 -2
metadata +4 -4

data/Rakefile CHANGED Viewed

@@ -23,6 +23,6 @@ begin
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError
-  puts "Jeweler not available. Install it with: sudo gem install jeweler -s http://gemcutter.org"
+  # if you get here, you need Jeweler installed to do packaging and gem installation, yo.
 end

data/VERSION CHANGED Viewed

	@@ -1 +1 @@
1	- 0.5.3
1	+ 0.5.4

data/lib/whiskey_disk.rb CHANGED Viewed

@@ -2,6 +2,8 @@ require File.expand_path(File.join(File.dirname(__FILE__), 'whiskey_disk', 'conf
 class WhiskeyDisk
   class << self
+    attr_writer :configuration
     def reset
       @configuration = nil
       @buffer = nil

data/spec/whiskey_disk/config_spec.rb CHANGED Viewed

@@ -1,9 +1,19 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper.rb'))
 require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'lib', 'whiskey_disk', 'config'))
 require 'yaml'
+require 'tmpdir'
+require 'fileutils'
-CURRENT_FILE = File.expand_path(__FILE__)           # Bacon evidently mucks around with __FILE__ or something related :-/
-CURRENT = File.expand_path(File.dirname(__FILE__))  # Bacon evidently mucks around with __FILE__ or something related :-/
+# create a file at the specified path
+def make(path)
+  FileUtils.mkdir_p(File.dirname(path))
+  FileUtils.touch(path)
+end
+def build_temp_dir
+  return Dir.mktmpdir(nil, '/private/tmp') if File.exists?('/private/tmp')
+  Dir.mktmpdir
+end
 describe WhiskeyDisk::Config do
   describe 'when computing the environment name' do
@@ -68,6 +78,12 @@ describe WhiskeyDisk::Config do
   describe 'when fetching configuration' do
     before do
       ENV['to'] = @env = 'foo:staging'
+      @path = build_temp_dir
+      ENV['path'] = @config_file = File.join(@path, 'deploy.yml')
+    end
+    after do
+      FileUtils.rm_rf(@path)
     end
     it 'should fail if the current environment cannot be determined' do
@@ -76,28 +92,27 @@ describe WhiskeyDisk::Config do
     end
     it 'should fail if the configuration file does not exist' do
-      WhiskeyDisk::Config.stub!(:configuration_file).and_return(__FILE__ + "_.crap")
       lambda { WhiskeyDisk::Config.fetch }.should.raise
     end
     it 'should fail if the configuration file cannot be read' do
-      WhiskeyDisk::Config.stub!(:configuration_file).and_return("/tmp")
+      Dir.mkdir(File.join(@path, 'tmp'))
       lambda { WhiskeyDisk::Config.fetch }.should.raise
     end
     it 'should fail if the configuration file is invalid' do
-      YAML.stub!(:load).and_raise
+      File.open(@config_file, 'w') {|f| f.puts "}" }
       lambda { WhiskeyDisk::Config.fetch }.should.raise
     end
     it 'should fail if the configuration file does not define data for this environment' do
-      WhiskeyDisk::Config.stub!(:configuration_data).and_return(YAML.dump({'foo' => { 'production' => { 'a' => 'b'}}}))
+      File.open(@config_file, 'w') {|f| f.puts YAML.dump({'foo' => { 'production' => { 'a' => 'b'}}}) }
       lambda { WhiskeyDisk::Config.fetch }.should.raise
     end
     it 'should return the configuration yaml file data for this environment as a hash' do
       staging = { 'foo' => 'bar', 'repository' => 'xyzzy' }
-      WhiskeyDisk::Config.stub!(:configuration_data).and_return(YAML.dump({'foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging }}))
+      File.open(@config_file, 'w') {|f| f.puts YAML.dump({'foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging }}) }
       result = WhiskeyDisk::Config.fetch
       staging.each_pair do |k,v|
         result[k].should == v
@@ -106,72 +121,85 @@ describe WhiskeyDisk::Config do
     it 'should not include configuration information for other environments in the returned hash' do
       staging = { 'foo' => 'bar', 'baz' => 'xyzzy' }
-      WhiskeyDisk::Config.stub!(:configuration_data).and_return(YAML.dump({ 'production' => { 'repository' => 'c', 'a' => 'b'}, 'staging' => staging }))
+      File.open(@config_file, 'w') {|f| f.puts YAML.dump({ 'production' => { 'repository' => 'c', 'a' => 'b'}, 'staging' => staging }) }
       WhiskeyDisk::Config.fetch['a'].should.be.nil
     end
     it 'should include the environment in the hash' do
       staging = { 'foo' => 'bar', 'baz' => 'xyzzy' }
-      WhiskeyDisk::Config.stub!(:configuration_data).and_return(YAML.dump({'foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging }}))
+      File.open(@config_file, 'w') {|f| f.puts YAML.dump({'foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging }}) }
       WhiskeyDisk::Config.fetch['environment'].should == 'staging'
     end
     it 'should not allow overriding the environment in the configuration file' do
       staging = { 'foo' => 'bar', 'repository' => 'xyzzy', 'environment' => 'production' }
-      WhiskeyDisk::Config.stub!(:configuration_data).and_return(YAML.dump({'foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging }}))
+      File.open(@config_file, 'w') {|f| f.puts YAML.dump({'foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging }}) }
       WhiskeyDisk::Config.fetch['environment'].should == 'staging'
     end
     it 'should include the project handle in the hash' do
       staging = { 'foo' => 'bar', 'repository' => 'xyzzy' }
-      WhiskeyDisk::Config.stub!(:configuration_data).and_return(YAML.dump({'foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging }}))
+      File.open(@config_file, 'w') {|f| f.puts YAML.dump({'foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging }}) }
       WhiskeyDisk::Config.fetch['project'].should == 'foo'
     end
     it 'should not allow overriding the project handle in the configuration file when a project root is specified' do
       staging = { 'foo' => 'bar', 'repository' => 'xyzzy', 'project' => 'diskey_whisk' }
-      WhiskeyDisk::Config.stub!(:configuration_data).and_return(YAML.dump({'foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging }}))
+      File.open(@config_file, 'w') {|f| f.puts YAML.dump({'foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging }}) }
       WhiskeyDisk::Config.fetch['project'].should == 'foo'
     end
     it 'should allow overriding the project handle in the configuration file when a project root is not specified' do
       ENV['to'] = @env = 'staging'
       staging = { 'foo' => 'bar', 'repository' => 'xyzzy', 'project' => 'diskey_whisk' }
-      WhiskeyDisk::Config.stub!(:configuration_data).and_return(YAML.dump({'production' => { 'repository' => 'b'}, 'staging' => staging }))
+      File.open(@config_file, 'w') {|f| f.puts YAML.dump({'production' => { 'repository' => 'b'}, 'staging' => staging }) }
       WhiskeyDisk::Config.fetch['project'].should == 'diskey_whisk'
     end
   end
   describe 'returning configuration data from a configuration file' do
+    before do
+      @path = build_temp_dir
+      ENV['path'] = @config_file = File.join(@path, 'deploy.yml')
+    end
+    after do
+      FileUtils.rm_rf(@path)
+    end
     it 'should fail if the configuration file does not exist' do
-      WhiskeyDisk::Config.stub!(:configuration_file).and_return(CURRENT_FILE + '._crap')
       lambda { WhiskeyDisk::Config.configuration_data }.should.raise
     end
     it 'should return the contents of the configuration file' do
-      WhiskeyDisk::Config.stub!(:configuration_file).and_return(CURRENT_FILE)
-      File.stub!(:read).with(CURRENT_FILE).and_return('file contents')
-      WhiskeyDisk::Config.configuration_data.should == 'file contents'
+      File.open(@config_file, 'w') { |f| f.puts "file contents" }
+      WhiskeyDisk::Config.configuration_data.should == "file contents\n"
     end
   end
   describe 'transforming data from the configuration file' do
+    before do
+      ENV['to'] = 'foo:bar'
+      @path = build_temp_dir
+      ENV['path'] = @config_file = File.join(@path, 'deploy.yml')
+    end
+    after do
+      FileUtils.rm_rf(@path)
+    end
     it 'should fail if the configuration data cannot be loaded' do
-      WhiskeyDisk::Config.stub!(:configuration_data).and_raise
       lambda { WhiskeyDisk::Config.load_data }.should.raise
     end
     it 'should fail if converting the configuration data from YAML fails' do
-      WhiskeyDisk::Config.stub!(:configuration_data).and_return('configuration data')
-      YAML.stub!(:load).and_raise
+      File.open(@config_file, 'w') { |f| f.puts "}" }
       lambda { WhiskeyDisk::Config.load_data }.should.raise
     end
     it 'should return a normalized version of the un-YAMLized configuration data' do
-      data = { 'a' => 'b', 'c' => 'd' }
-      WhiskeyDisk::Config.stub!(:configuration_data).and_return(YAML.dump(data))
-      WhiskeyDisk::Config.stub!(:normalize_data).with(data).and_return('normalized data')
-      WhiskeyDisk::Config.load_data.should == 'normalized data'
+      File.open(@config_file, 'w') { |f| f.puts YAML.dump({ 'repository' => 'x'}) }
+      WhiskeyDisk::Config.load_data.should == { 'foo' => { 'bar' => { 'repository' => 'x' } } }
     end
   end
@@ -286,187 +314,199 @@ describe WhiskeyDisk::Config do
     describe 'and no path is specified' do
       before do
         ENV['path'] = @path = nil
+        @original_path = Dir.pwd
+        @base_path = build_temp_dir
+        Dir.chdir(@base_path)
+        FileUtils.touch(File.join(@base_path, 'Rakefile'))
+        @dir = File.join(@base_path, 'config')
+        Dir.mkdir(@dir)
+        [
+          "/deploy/foo/staging.yml",
+          "/deploy/foo.yml",
+          "/deploy/staging.yml",
+          "/staging.yml",
+          "/deploy.yml"
+        ].each { |file| make(File.join(@dir, file)) }
       end
+      after do
+        FileUtils.rm_rf(@base_path)
+        Dir.chdir(@original_path)
+      end
       describe 'and a project name is specified in ENV["to"]' do
         before do
           ENV['to'] = @env = 'foo:staging'
         end
         it 'should return the path to deploy/foo/<environment>.yml under the project base path if it exists' do
-          WhiskeyDisk::Config.stub!(:base_path).and_return('/path/to/project/config')
-          File.stub!(:exists?).with('/path/to/project/config/deploy/foo/staging.yml').and_return(true)
-          WhiskeyDisk::Config.configuration_file.should == '/path/to/project/config/deploy/foo/staging.yml'
+          WhiskeyDisk::Config.configuration_file.should == "#{@dir}/deploy/foo/staging.yml"
         end
         it 'should return the path to deploy/foo.yml under the project base path if it exists' do
-          WhiskeyDisk::Config.stub!(:base_path).and_return('/path/to/project/config')
-          File.stub!(:exists?).with('/path/to/project/config/deploy/foo/staging.yml').and_return(false)
-          File.stub!(:exists?).with('/path/to/project/config/deploy/foo.yml').and_return(true)
-          WhiskeyDisk::Config.configuration_file.should == '/path/to/project/config/deploy/foo.yml'
+          File.unlink("#{@dir}/deploy/foo/staging.yml")
+          WhiskeyDisk::Config.configuration_file.should == "#{@dir}/deploy/foo.yml"
         end
         it 'should return the path to a per-environment configuration file in the deploy/ directory under the project base path if it exists' do
-          WhiskeyDisk::Config.stub!(:base_path).and_return('/path/to/project/config')
-          File.stub!(:exists?).with('/path/to/project/config/deploy/foo/staging.yml').and_return(false)
-          File.stub!(:exists?).with('/path/to/project/config/deploy/foo.yml').and_return(false)
-          File.stub!(:exists?).with('/path/to/project/config/deploy/staging.yml').and_return(true)
-          WhiskeyDisk::Config.configuration_file.should == '/path/to/project/config/deploy/staging.yml'
+          File.unlink("#{@dir}/deploy/foo/staging.yml")
+          File.unlink("#{@dir}/deploy/foo.yml")
+          WhiskeyDisk::Config.configuration_file.should == "#{@dir}/deploy/staging.yml"
         end
         it 'should return the path to a per-environment configuration file under the project base path if it exists' do
-          WhiskeyDisk::Config.stub!(:base_path).and_return('/path/to/project/config')
-          File.stub!(:exists?).with('/path/to/project/config/deploy/foo/staging.yml').and_return(false)
-          File.stub!(:exists?).with('/path/to/project/config/deploy/foo.yml').and_return(false)
-          File.stub!(:exists?).with('/path/to/project/config/deploy/staging.yml').and_return(false)
-          File.stub!(:exists?).with('/path/to/project/config/staging.yml').and_return(true)
-          WhiskeyDisk::Config.configuration_file.should == '/path/to/project/config/staging.yml'
+          File.unlink("#{@dir}/deploy/foo/staging.yml")
+          File.unlink("#{@dir}/deploy/foo.yml")
+          File.unlink("#{@dir}/deploy/staging.yml")
+          WhiskeyDisk::Config.configuration_file.should == "#{@dir}/staging.yml"
         end
         it 'should return the path to deploy.yml under the project base path' do
-          WhiskeyDisk::Config.stub!(:base_path).and_return('/path/to/project/config')
-          File.stub!(:exists?).with('/path/to/project/config/deploy/foo/staging.yml').and_return(false)
-          File.stub!(:exists?).with('/path/to/project/config/deploy/foo.yml').and_return(false)
-          File.stub!(:exists?).with('/path/to/project/config/deploy/staging.yml').and_return(false)
-          File.stub!(:exists?).with('/path/to/project/config/staging.yml').and_return(false)
-          File.stub!(:exists?).with('/path/to/project/config/deploy.yml').and_return(true)
-          WhiskeyDisk::Config.configuration_file.should == '/path/to/project/config/deploy.yml'
+          File.unlink("#{@dir}/deploy/foo/staging.yml")
+          File.unlink("#{@dir}/deploy/foo.yml")
+          File.unlink("#{@dir}/deploy/staging.yml")
+          File.unlink("#{@dir}/staging.yml")
+          WhiskeyDisk::Config.configuration_file.should == "#{@dir}/deploy.yml"
         end
         it 'should fail if no per-environment config file nor deploy.yml exists under the project base path' do
-          WhiskeyDisk::Config.stub!(:base_path).and_return('/path/to/project/config')
-          File.stub!(:exists?).with('/path/to/project/config/deploy/foo/staging.yml').and_return(false)
-          File.stub!(:exists?).with('/path/to/project/config/deploy/foo.yml').and_return(false)
-          File.stub!(:exists?).with('/path/to/project/config/deploy/staging.yml').and_return(false)
-          File.stub!(:exists?).with('/path/to/project/config/staging.yml').and_return(false)
-          File.stub!(:exists?).with('/path/to/project/config/deploy.yml').and_return(false)
+          File.unlink("#{@dir}/deploy/foo/staging.yml")
+          File.unlink("#{@dir}/deploy/foo.yml")
+          File.unlink("#{@dir}/deploy/staging.yml")
+          File.unlink("#{@dir}/staging.yml")
+          File.unlink("#{@dir}/deploy.yml")
           lambda { WhiskeyDisk::Config.configuration_file }.should.raise
         end
       end
       describe 'and no project name is specified in ENV["to"]' do
         it 'should return the path to a per-environment configuration file in the deploy/ directory under the project base path if it exists' do
-          WhiskeyDisk::Config.stub!(:base_path).and_return('/path/to/project/config')
-          File.stub!(:exists?).with('/path/to/project/config/deploy/staging.yml').and_return(true)
-          WhiskeyDisk::Config.configuration_file.should == '/path/to/project/config/deploy/staging.yml'
+          WhiskeyDisk::Config.configuration_file.should == "#{@dir}/deploy/staging.yml"
         end
         it 'should return the path to a per-environment configuration file under the project base path if it exists' do
-          WhiskeyDisk::Config.stub!(:base_path).and_return('/path/to/project/config')
-          File.stub!(:exists?).with('/path/to/project/config/deploy/staging.yml').and_return(false)
-          File.stub!(:exists?).with('/path/to/project/config/staging.yml').and_return(true)
-          WhiskeyDisk::Config.configuration_file.should == '/path/to/project/config/staging.yml'
+          File.unlink("#{@dir}/deploy/staging.yml")
+          WhiskeyDisk::Config.configuration_file.should == "#{@dir}/staging.yml"
         end
         it 'should return the path to deploy.yml under the project base path' do
-          WhiskeyDisk::Config.stub!(:base_path).and_return('/path/to/project/config')
-          File.stub!(:exists?).with('/path/to/project/config/deploy/staging.yml').and_return(false)
-          File.stub!(:exists?).with('/path/to/project/config/staging.yml').and_return(false)
-          File.stub!(:exists?).with('/path/to/project/config/deploy.yml').and_return(true)
-          WhiskeyDisk::Config.configuration_file.should == '/path/to/project/config/deploy.yml'
+          File.unlink("#{@dir}/deploy/staging.yml")
+          File.unlink("#{@dir}/staging.yml")
+          WhiskeyDisk::Config.configuration_file.should == "#{@dir}/deploy.yml"
         end
         it 'should fail if no per-environment config file nor deploy.yml exists under the project base path' do
-          WhiskeyDisk::Config.stub!(:base_path).and_return('/path/to/project/config')
-          File.stub!(:exists?).with('/path/to/project/config/deploy/staging.yml').and_return(false)
-          File.stub!(:exists?).with('/path/to/project/config/staging.yml').and_return(false)
-          File.stub!(:exists?).with('/path/to/project/config/deploy.yml').and_return(false)
+          File.unlink("#{@dir}/deploy/staging.yml")
+          File.unlink("#{@dir}/staging.yml")
+          File.unlink("#{@dir}/deploy.yml")
           lambda { WhiskeyDisk::Config.configuration_file }.should.raise
         end
       end
     end
-    it 'should fail if a path is specified which does not exist' do
-      ENV['path'] = @path = (CURRENT_FILE + "_.crap")
-      lambda { WhiskeyDisk::Config.configuration_file }.should.raise
-    end
+    describe 'and looking up a file' do
+      before do
+        @path = build_temp_dir
+        ENV['path'] = @config_file = File.join(@path, 'deploy.yml')
+      end
+      after do
+        FileUtils.rm_rf(@path)
+      end
+      it 'should fail if a path is specified which does not exist' do
+        lambda { WhiskeyDisk::Config.configuration_file }.should.raise
+      end
-    it 'should return the file path when a path which points to an existing file is specified' do
-      ENV['path'] = @path = CURRENT_FILE
-      File.stub!(:exists?).with(@path).and_return(true)
-      WhiskeyDisk::Config.configuration_file.should == @path
+      it 'should return the file path when a path which points to an existing file is specified' do
+        FileUtils.touch(@config_file)
+        WhiskeyDisk::Config.configuration_file.should == @config_file
+      end
     end
     describe 'and a path which points to a directory is specified' do
       before do
-        ENV['path'] = @path = CURRENT
+        ENV['path'] = @path = build_temp_dir
+        [
+          "/deploy/foo/staging.yml",
+          "/deploy/foo.yml",
+          "/deploy/staging.yml",
+          "/staging.yml",
+          "/deploy.yml"
+        ].each { |file| make(File.join(@path, file)) }
       end
+      after do
+        FileUtils.rm_rf(@path)
+      end
       describe 'and a project name is specified in ENV["to"]' do
         before do
           ENV['to'] = @env = 'foo:staging'
         end
         it 'should return the path to deploy/foo/<environment>.yml under the project base path if it exists' do
-          WhiskeyDisk::Config.stub!(:base_path).and_return(@path)
-          File.stub!(:exists?).with(File.join(@path, 'deploy', 'foo', 'staging.yml')).and_return(true)
           WhiskeyDisk::Config.configuration_file.should == File.join(@path, 'deploy', 'foo' ,'staging.yml')
         end
         it 'should return the path to deploy/foo.yml under the project base path if it exists' do
-          WhiskeyDisk::Config.stub!(:base_path).and_return(@path)
-          File.stub!(:exists?).with(File.join(@path, 'deploy', 'foo', 'staging.yml')).and_return(false)
-          File.stub!(:exists?).with(File.join(@path, 'deploy', 'foo.yml')).and_return(true)
+          File.unlink(File.join(@path, 'deploy', 'foo', 'staging.yml'))
           WhiskeyDisk::Config.configuration_file.should == File.join(@path, 'deploy', 'foo.yml')
         end
         it 'should return the path to a per-environment configuration file under deploy/ in the path specified if that file exists' do
-          File.stub!(:exists?).with(File.join(@path, 'deploy', 'foo', 'staging.yml')).and_return(false)
-          File.stub!(:exists?).with(File.join(@path, 'deploy', 'foo.yml')).and_return(false)
-          File.stub!(:exists?).with(File.join(@path, 'deploy', 'staging.yml')).and_return(true)
+          File.unlink(File.join(@path, 'deploy', 'foo', 'staging.yml'))
+          File.unlink(File.join(@path, 'deploy', 'foo.yml'))
           WhiskeyDisk::Config.configuration_file.should == File.join(@path, 'deploy', 'staging.yml')
         end
         it 'should return the path to a per-environment configuration file in the path specified if that file exists' do
-          File.stub!(:exists?).with(File.join(@path, 'deploy', 'foo', 'staging.yml')).and_return(false)
-          File.stub!(:exists?).with(File.join(@path, 'deploy', 'foo.yml')).and_return(false)
-          File.stub!(:exists?).with(File.join(@path, 'deploy', 'staging.yml')).and_return(false)
-          File.stub!(:exists?).with(File.join(@path, 'staging.yml')).and_return(true)
+          File.unlink(File.join(@path, 'deploy', 'foo', 'staging.yml'))
+          File.unlink(File.join(@path, 'deploy', 'foo.yml'))
+          File.unlink(File.join(@path, 'deploy', 'staging.yml'))
           WhiskeyDisk::Config.configuration_file.should == File.join(@path, 'staging.yml')
         end
         it 'should return the path to deploy.yaml in the path specified if deploy.yml exists' do
-          File.stub!(:exists?).with(File.join(@path, 'deploy', 'foo', 'staging.yml')).and_return(false)
-          File.stub!(:exists?).with(File.join(@path, 'deploy', 'foo.yml')).and_return(false)
-          File.stub!(:exists?).with(File.join(@path, 'deploy', 'staging.yml')).and_return(false)
-          File.stub!(:exists?).with(File.join(@path, 'staging.yml')).and_return(false)
-          File.stub!(:exists?).with(File.join(@path, 'deploy.yml')).and_return(true)
+          File.unlink(File.join(@path, 'deploy', 'foo', 'staging.yml'))
+          File.unlink(File.join(@path, 'deploy', 'foo.yml'))
+          File.unlink(File.join(@path, 'deploy', 'staging.yml'))
+          File.unlink(File.join(@path, 'staging.yml'))
           WhiskeyDisk::Config.configuration_file.should == File.join(@path, 'deploy.yml')
         end
         it 'should fail if no per-environment configuration file nor deploy.yml exists in the path specified' do
-          File.stub!(:exists?).with(File.join(@path, 'deploy', 'foo', 'staging.yml')).and_return(false)
-          File.stub!(:exists?).with(File.join(@path, 'deploy', 'foo.yml')).and_return(false)
-          File.stub!(:exists?).with(File.join(@path, 'deploy', 'staging.yml')).and_return(false)
-          File.stub!(:exists?).with(File.join(@path, 'staging.yml')).and_return(false)
-          File.stub!(:exists?).with(File.join(@path, 'deploy.yml')).and_return(false)
+          File.unlink(File.join(@path, 'deploy', 'foo', 'staging.yml'))
+          File.unlink(File.join(@path, 'deploy', 'foo.yml'))
+          File.unlink(File.join(@path, 'deploy', 'staging.yml'))
+          File.unlink(File.join(@path, 'staging.yml'))
+          File.unlink(File.join(@path, 'deploy.yml'))
           lambda { WhiskeyDisk::Config.configuration_file }.should.raise
         end
       end
       describe 'and no project name is specified in ENV["to"]' do
         it 'should return the path to a per-environment configuration file under deploy/ in the path specified if that file exists' do
-          File.stub!(:exists?).with(File.join(@path, 'deploy', 'staging.yml')).and_return(true)
           WhiskeyDisk::Config.configuration_file.should == File.join(@path, 'deploy', 'staging.yml')
         end
         it 'should return the path to a per-environment configuration file in the path specified if that file exists' do
-          File.stub!(:exists?).with(File.join(@path, 'deploy', 'staging.yml')).and_return(false)
-          File.stub!(:exists?).with(File.join(@path, 'staging.yml')).and_return(true)
+          File.unlink(File.join(@path, 'deploy', 'staging.yml'))
           WhiskeyDisk::Config.configuration_file.should == File.join(@path, 'staging.yml')
         end
         it 'should return the path to deploy.yaml in the path specified if deploy.yml exists' do
-          File.stub!(:exists?).with(File.join(@path, 'deploy', 'staging.yml')).and_return(false)
-          File.stub!(:exists?).with(File.join(@path, 'staging.yml')).and_return(false)
-          File.stub!(:exists?).with(File.join(@path, 'deploy.yml')).and_return(true)
+          File.unlink(File.join(@path, 'deploy', 'staging.yml'))
+          File.unlink(File.join(@path, 'staging.yml'))
           WhiskeyDisk::Config.configuration_file.should == File.join(@path, 'deploy.yml')
         end
         it 'should fail if no per-environment configuration file nor deploy.yml exists in the path specified' do
-          File.stub!(:exists?).with(File.join(@path, 'deploy', 'staging.yml')).and_return(false)
-          File.stub!(:exists?).with(File.join(@path, 'staging.yml')).and_return(false)
-          File.stub!(:exists?).with(File.join(@path, 'deploy.yml')).and_return(false)
+          File.unlink(File.join(@path, 'deploy', 'staging.yml'))
+          File.unlink(File.join(@path, 'staging.yml'))
+          File.unlink(File.join(@path, 'deploy.yml'))
           lambda { WhiskeyDisk::Config.configuration_file }.should.raise
         end
       end
@@ -485,8 +525,13 @@ describe WhiskeyDisk::Config do
     describe 'and a "path" environment variable is set' do
       before do
-        ENV['path'] = @path = CURRENT
-        Dir.chdir(CURRENT)
+        ENV['path'] = @path = build_temp_dir
+        @original_path = Dir.pwd
+      end
+      after do
+        FileUtils.rm_rf(@path)
+        Dir.chdir(@original_path)
       end
       it 'should return the path set in the "path" environment variable' do
@@ -495,41 +540,54 @@ describe WhiskeyDisk::Config do
       it 'should leave the current working path the same as when the base path lookup started' do
         WhiskeyDisk::Config.base_path
-        Dir.pwd.should == CURRENT
+        Dir.pwd.should == @original_path
       end
     end
     describe 'and there is no Rakefile in the root path to the current directory' do
       before do
-        Dir.chdir(CURRENT)
-        WhiskeyDisk::Config.stub!(:contains_rakefile?).and_return(false)
+        @original_path = Dir.pwd
+        @path = build_temp_dir
+        Dir.chdir(@path)
+      end
+      after do
+        Dir.chdir(@original_path)
+        FileUtils.rm_rf(@path)
       end
       it 'should return the config directory under the current directory if there is no Rakefile along the root path to the current directory' do
-        WhiskeyDisk::Config.base_path.should == File.join(CURRENT, 'config')
+        WhiskeyDisk::Config.base_path.should == File.join(@path, 'config')
       end
       it 'should leave the current working path the same as when the base path lookup started' do
+        prior = Dir.pwd
         WhiskeyDisk::Config.base_path
-        Dir.pwd.should == CURRENT
+        Dir.pwd.should == prior
       end
     end
     describe 'and there is a Rakefile in the root path to the current directory' do
       before do
-        @top = ::File.expand_path(File.join(CURRENT, '..', '..'))
-        WhiskeyDisk::Config.stub!(:contains_rakefile?).and_return(false)
-        WhiskeyDisk::Config.stub!(:contains_rakefile?).with(@top).and_return(true)
-        Dir.chdir(CURRENT)
+        @original_path = Dir.pwd
+        @path = build_temp_dir
+        Dir.chdir(@path)
+        FileUtils.touch(File.join(@path, 'Rakefile'))
+      end
+      after do
+        Dir.chdir(@original_path)
+        FileUtils.rm_rf(@path)
       end
       it 'return the config directory in the nearest enclosing path with a Rakefile along the root path to the current directory' do
-        WhiskeyDisk::Config.base_path.should == File.join(@top, 'config')
+        WhiskeyDisk::Config.base_path.should == File.join(@path, 'config')
       end
       it 'should leave the current working path the same as when the base path lookup started' do
+        prior = Dir.pwd
         WhiskeyDisk::Config.base_path
-        Dir.pwd.should == CURRENT
+        Dir.pwd.should == prior
       end
     end
   end

data/spec/whiskey_disk/rake_spec.rb CHANGED Viewed

@@ -14,8 +14,7 @@ describe 'rake tasks' do
   describe 'deploy:setup' do
     before do
-      @configuration = { }
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@configuration)
+      WhiskeyDisk.configuration = {}
       [
         :ensure_main_parent_path_is_present,
         :ensure_config_parent_path_is_present,
@@ -33,15 +32,13 @@ describe 'rake tasks' do
     end
     it 'should make changes on the specified domain when a domain is specified' do
-      @configuration = { 'domain' => 'some domain' }
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@configuration)
+      WhiskeyDisk.configuration = { 'domain' => 'some domain' }
       @rake["deploy:setup"].invoke
       WhiskeyDisk.should.be.remote
     end
     it 'should make changes on the local system when no domain is specified' do
-      @configuration = { 'domain' => '' }
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@configuration)
+      WhiskeyDisk.configuration = { 'domain' => '' }
       WhiskeyDisk.should.not.be.remote
     end
@@ -52,7 +49,7 @@ describe 'rake tasks' do
     describe 'when a configuration repo is specified' do
       it 'should ensure that the parent path for the configuration repository checkout is present' do
-        WhiskeyDisk.stub!(:has_config_repo?).and_return(true)
+        WhiskeyDisk.configuration = { 'config_repository' => 'foo' }
         WhiskeyDisk.should.receive(:ensure_config_parent_path_is_present)
         @rake["deploy:setup"].invoke
       end
@@ -60,7 +57,6 @@ describe 'rake tasks' do
     describe 'when no configuration repo is specified' do
       it 'should not ensure that the path for the configuration repository checkout is present' do
-        WhiskeyDisk.stub!(:has_config_repo?).and_return(false)
         WhiskeyDisk.should.not.receive(:ensure_config_parent_path_is_present)
         @rake["deploy:setup"].invoke
       end
@@ -73,7 +69,7 @@ describe 'rake tasks' do
     describe 'when a configuration repository is specified' do
       it 'should check out the configuration repository' do
-        WhiskeyDisk.stub!(:has_config_repo?).and_return(true)
+        WhiskeyDisk.configuration = { 'config_repository' => 'foo' }
         WhiskeyDisk.should.receive(:checkout_configuration_repository)
         @rake["deploy:setup"].invoke
       end
@@ -81,7 +77,6 @@ describe 'rake tasks' do
     describe 'when no configuration repository is specified' do
       it 'should not check out the configuration repository' do
-        WhiskeyDisk.stub!(:has_config_repo?).and_return(false)
         WhiskeyDisk.should.not.receive(:checkout_configuration_repository)
         @rake["deploy:setup"].invoke
       end
@@ -94,7 +89,7 @@ describe 'rake tasks' do
     describe 'when a configuration repository is specified' do
       it 'should update the configuration repository checkout' do
-        WhiskeyDisk.stub!(:has_config_repo?).and_return(true)
+        WhiskeyDisk.configuration = { 'config_repository' => 'foo' }
         WhiskeyDisk.should.receive(:update_configuration_repository_checkout)
         @rake["deploy:setup"].invoke
       end
@@ -102,7 +97,6 @@ describe 'rake tasks' do
     describe 'when no configuration repository is specified' do
       it 'should update the configuration repository checkout' do
-        WhiskeyDisk.stub!(:has_config_repo?).and_return(false)
         WhiskeyDisk.should.not.receive(:update_configuration_repository_checkout)
         @rake["deploy:setup"].invoke
       end
@@ -110,7 +104,7 @@ describe 'rake tasks' do
     describe 'when a configuration repository is specified' do
       it 'should refresh the configuration' do
-        WhiskeyDisk.stub!(:has_config_repo?).and_return(true)
+        WhiskeyDisk.configuration = { 'config_repository' => 'foo' }
         WhiskeyDisk.should.receive(:refresh_configuration)
         @rake["deploy:setup"].invoke
       end
@@ -118,7 +112,6 @@ describe 'rake tasks' do
     describe 'when no configuration repository is specified' do
       it 'should not refresh the configuration' do
-        WhiskeyDisk.stub!(:has_config_repo?).and_return(false)
         WhiskeyDisk.should.not.receive(:refresh_configuration)
         @rake["deploy:setup"].invoke
       end
@@ -137,8 +130,7 @@ describe 'rake tasks' do
   describe 'deploy:now' do
     before do
-      @configuration = { }
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@configuration)
+      WhiskeyDisk.configuration = { }
       [
         :enable_staleness_checks,
         :update_main_repository_checkout,
@@ -152,8 +144,7 @@ describe 'rake tasks' do
     end
     it 'should make changes on the specified domain when a domain is specified' do
-      @configuration = { 'domain' => 'some domain'}
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@configuration)
+      WhiskeyDisk.configuration = { 'domain' => 'some domain'}
       @rake["deploy:now"].invoke
       WhiskeyDisk.should.be.remote
     end
@@ -174,7 +165,7 @@ describe 'rake tasks' do
     describe 'when a configuration repository is specified' do
       it 'should update the configuration repository checkout' do
-        WhiskeyDisk.stub!(:has_config_repo?).and_return(true)
+        WhiskeyDisk.configuration = { 'config_repository' => 'foo' }
         WhiskeyDisk.should.receive(:update_configuration_repository_checkout)
         @rake["deploy:now"].invoke
       end
@@ -182,7 +173,6 @@ describe 'rake tasks' do
     describe 'when no configuration repository is specified' do
       it 'should not update the configuration repository checkout' do
-        WhiskeyDisk.stub!(:has_config_repo?).and_return(false)
         WhiskeyDisk.should.not.receive(:update_configuration_repository_checkout)
         @rake["deploy:now"].invoke
       end
@@ -190,7 +180,7 @@ describe 'rake tasks' do
     describe 'when a configuration repository is specified' do
       it 'should refresh the configuration' do
-        WhiskeyDisk.stub!(:has_config_repo?).and_return(true)
+        WhiskeyDisk.configuration = { 'config_repository' => 'foo' }
         WhiskeyDisk.should.receive(:refresh_configuration)
         @rake["deploy:now"].invoke
       end
@@ -198,7 +188,6 @@ describe 'rake tasks' do
     describe 'when no configuration repository is specified' do
       it 'should not refresh the configuration' do
-        WhiskeyDisk.stub!(:has_config_repo?).and_return(false)
         WhiskeyDisk.should.not.receive(:refresh_configuration)
         @rake["deploy:now"].invoke
       end
@@ -217,9 +206,7 @@ describe 'rake tasks' do
   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
-      @configuration = { 'environment' => 'production'}
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@configuration)
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = { 'environment' => 'production'}
       task "deploy:production:post_setup" do
         WhiskeyDisk.fake_method
@@ -230,18 +217,14 @@ describe 'rake tasks' do
     end
     it 'should not fail when no post_setup rake task is defined for this environment' do
-      @configuration = { 'environment' => 'staging'}
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@configuration)
-      WhiskeyDisk.reset
+      WhiskeyDisk.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
-      @configuration = { 'environment' => 'production'}
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@configuration)
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = { 'environment' => 'production'}
       task "deploy:production:post_deploy" do
         WhiskeyDisk.fake_method
@@ -252,9 +235,7 @@ describe 'rake tasks' do
     end
     it 'should not fail when no post_deploy rake task is defined for this environment' do
-      @configuration = { 'environment' => 'staging'}
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@configuration)
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = { 'environment' => 'staging'}
       lambda { Rake::Task['deploy:post_deploy'].invoke }.should.not.raise
     end
   end

data/spec/whiskey_disk_spec.rb CHANGED Viewed

@@ -25,8 +25,7 @@ describe 'WhiskeyDisk' do
   describe 'determining if the deployment is remote' do
     before do
       @parameters = { 'deploy_to' => '/path/to/main/repo' }
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters
     end
     it 'should work without arguments' do
@@ -56,8 +55,7 @@ describe 'WhiskeyDisk' do
   describe 'determining if the deployment has a configuration repository' do
     before do
       @parameters = { 'deploy_to' => '/path/to/main/repo' }
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters
     end
     it 'should work without arguments' do
@@ -107,14 +105,11 @@ describe 'WhiskeyDisk' do
   describe 'ensuring that the parent path for the main repository checkout is present' do
     before do
-      @parameters = { 'deploy_to' => '/path/to/main/repo' }
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = { 'deploy_to' => '/path/to/main/repo' }
     end
     it 'should fail if the deployment path is not specified' do
-      WhiskeyDisk::Config.stub!(:fetch).and_return({})
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = {}
       lambda { WhiskeyDisk.ensure_main_parent_path_is_present }.should.raise
     end
@@ -127,14 +122,11 @@ describe 'WhiskeyDisk' do
   describe 'ensuring that the parent path for the configuration repository checkout is present' do
     before do
-      @parameters = { 'deploy_config_to' => '/path/to/config/repo' }
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = { 'deploy_config_to' => '/path/to/config/repo' }
     end
     it 'should fail if the configuration deployment path is not specified' do
-      WhiskeyDisk::Config.stub!(:fetch).and_return({})
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = {}
       lambda { WhiskeyDisk.ensure_config_parent_path_is_present }.should.raise
     end
@@ -148,19 +140,16 @@ describe 'WhiskeyDisk' do
   describe 'checking out the main repository' do
     before do
       @parameters = { 'deploy_to' => '/path/to/main/repo', 'repository' => 'git@ogtastic.com:whiskey_disk.git' }
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters
     end
     it 'should fail if the deployment path is not specified' do
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters.merge('deploy_to' => nil))
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters.merge('deploy_to' => nil)
       lambda { WhiskeyDisk.checkout_main_repository }.should.raise
     end
     it 'should fail if the repository is not specified' do
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters.merge('repository' => nil))
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters.merge('repository' => nil)
       lambda { WhiskeyDisk.checkout_main_repository }.should.raise
     end
@@ -184,19 +173,16 @@ describe 'WhiskeyDisk' do
   describe 'checking out the configuration repository' do
     before do
       @parameters = { 'deploy_config_to' => '/path/to/config/repo', 'config_repository' => 'git@ogtastic.com:config.git' }
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters
     end
     it 'should fail if the configuration deployment path is not specified' do
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters.merge('deploy_config_to' => nil))
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters.merge('deploy_config_to' => nil)
       lambda { WhiskeyDisk.checkout_configuration_repository }.should.raise
     end
     it 'should fail if the configuration repository is not specified' do
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters.merge('config_repository' => nil))
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters.merge('config_repository' => nil)
       lambda { WhiskeyDisk.checkout_configuration_repository }.should.raise
     end
@@ -220,13 +206,11 @@ describe 'WhiskeyDisk' do
   describe 'updating the main repository checkout' do
     before do
       @parameters = { 'deploy_to' => '/path/to/main/repo' }
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters
     end
     it 'should fail if the deployment path is not specified' do
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters.merge('deploy_to' => nil))
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters.merge('deploy_to' => nil)
       lambda { WhiskeyDisk.update_main_repository_checkout }.should.raise
     end
@@ -241,8 +225,7 @@ describe 'WhiskeyDisk' do
     end
     it 'should attempt to fetch the specified branch from the origin if a branch is specified' do
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters.merge({'branch' => 'production'}))
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters.merge({'branch' => 'production'})
       WhiskeyDisk.update_main_repository_checkout
       WhiskeyDisk.buffer.join(' ').should.match(%r{git fetch origin \+refs/heads/production:refs/remotes/origin/production})
     end
@@ -253,8 +236,7 @@ describe 'WhiskeyDisk' do
     end
     it 'should attempt to reset the specified branch from the origin if a branch is specified' do
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters.merge({'branch' => 'production'}))
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters.merge({'branch' => 'production'})
       WhiskeyDisk.update_main_repository_checkout
       WhiskeyDisk.buffer.join(' ').should.match(%r{git reset --hard origin/production})
     end
@@ -263,13 +245,11 @@ describe 'WhiskeyDisk' do
   describe 'updating the configuration repository checkout' do
     before do
       @parameters = { 'deploy_config_to' => '/path/to/config/repo' }
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters
     end
     it 'should fail if the configuration deployment path is not specified' do
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters.merge('deploy_config_to' => nil))
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters.merge('deploy_config_to' => nil)
       lambda { WhiskeyDisk.update_configuration_repository_checkout }.should.raise
     end
@@ -284,8 +264,7 @@ describe 'WhiskeyDisk' do
     end
     it 'should attempt to fetch the specified branch from the origin if a configuration branch is specified' do
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters.merge({'config_branch' => 'production'}))
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters.merge({'config_branch' => 'production'})
       WhiskeyDisk.update_configuration_repository_checkout
       WhiskeyDisk.buffer.join(' ').should.match(%r{git fetch origin \+refs/heads/production:refs/remotes/origin/production})
     end
@@ -296,8 +275,7 @@ describe 'WhiskeyDisk' do
     end
     it 'should attempt to reset the master branch from the origin if no configuration branch is specified' do
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters.merge({'config_branch' => 'production'}))
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters.merge({'config_branch' => 'production'})
       WhiskeyDisk.update_configuration_repository_checkout
       WhiskeyDisk.buffer.join(' ').should.match(%r{git reset --hard origin/production})
     end
@@ -311,25 +289,21 @@ describe 'WhiskeyDisk' do
                       'config_repository' => 'git@git://foo.bar.git',
                       'config_branch' => 'master',
                       'project' => 'whiskey_disk' }
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters
     end
     it 'should fail if the main deployment path is not specified' do
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters.merge('deploy_to' => nil))
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters.merge('deploy_to' => nil)
       lambda { WhiskeyDisk.refresh_configuration }.should.raise
     end
     it 'should fail if the configuration deployment path is not specified' do
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters.merge('deploy_config_to' => nil))
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters.merge('deploy_config_to' => nil)
       lambda { WhiskeyDisk.refresh_configuration }.should.raise
     end
     it 'should fail if no project name was specified' do
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters.merge('project' => 'unnamed_project'))
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters.merge('project' => 'unnamed_project')
       lambda { WhiskeyDisk.refresh_configuration }.should.raise
     end
@@ -341,14 +315,11 @@ describe 'WhiskeyDisk' do
   describe 'running post setup hooks' do
     before do
-      @parameters = { 'deploy_to' => '/path/to/main/repo' }
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = { 'deploy_to' => '/path/to/main/repo' }
     end
     it 'should fail if the deployment path is not specified' do
-      WhiskeyDisk::Config.stub!(:fetch).and_return({})
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = {}
       lambda { WhiskeyDisk.run_post_setup_hooks }.should.raise
     end
@@ -360,10 +331,7 @@ describe 'WhiskeyDisk' do
     describe 'when a post setup script is specified' do
       describe 'and the script path does not start with a "/"' do
         before do
-          @parameters = { 'deploy_to'          => '/path/to/main/repo',
-                          'post_setup_script' => '/path/to/setup/script' }
-          WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-          WhiskeyDisk.reset
+          WhiskeyDisk.configuration = { 'deploy_to' => '/path/to/main/repo', 'post_setup_script' => '/path/to/setup/script' }
         end
         it 'should attempt to run the post setup script' do
@@ -384,10 +352,7 @@ describe 'WhiskeyDisk' do
       describe 'and the script path does not start with a "/"' do
         before do
-          @parameters = { 'deploy_to'          => '/path/to/main/repo',
-                          'post_setup_script' => 'path/to/setup/script' }
-          WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-          WhiskeyDisk.reset
+          WhiskeyDisk.configuration = { 'deploy_to' => '/path/to/main/repo', 'post_setup_script' => 'path/to/setup/script' }
         end
         it 'should attempt to run the post setup script' do
@@ -429,8 +394,7 @@ describe 'WhiskeyDisk' do
     it 'should ensure that any rake ENV variable are set when checking for deploy:post_setup tasks' do
       @parameters = { 'deploy_to' => '/path/to/main/repo', 'rake_env' => { 'RAILS_ENV' => 'production', 'FOO' => 'bar' } }
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters
       WhiskeyDisk.run_post_setup_hooks
       @parameters['rake_env'].each_pair do |k,v|
         WhiskeyDisk.buffer.join(' ').should.match(%r{#{k}='#{v}' .*rake -P})
@@ -439,8 +403,7 @@ describe 'WhiskeyDisk' do
     it 'should set any rake_env variables when running the rake tasks' do
       @parameters = { 'deploy_to' => '/path/to/main/repo', 'rake_env' => { 'RAILS_ENV' => 'production', 'FOO' => 'bar' } }
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters
       WhiskeyDisk.run_post_setup_hooks
       @parameters['rake_env'].each_pair do |k,v|
         WhiskeyDisk.buffer.join(' ').should.match(%r{#{k}='#{v}' })
@@ -450,14 +413,11 @@ describe 'WhiskeyDisk' do
   describe 'running post deployment hooks' do
     before do
-      @parameters = { 'deploy_to' => '/path/to/main/repo' }
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = { 'deploy_to' => '/path/to/main/repo' }
     end
     it 'should fail if the deployment path is not specified' do
-      WhiskeyDisk::Config.stub!(:fetch).and_return({})
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = {}
       lambda { WhiskeyDisk.run_post_deploy_hooks }.should.raise
     end
@@ -469,10 +429,7 @@ describe 'WhiskeyDisk' do
     describe 'when a post deployment script is specified' do
       describe 'and the script path does not start with a "/"' do
         before do
-          @parameters = { 'deploy_to'          => '/path/to/main/repo',
-                          'post_deploy_script' => '/path/to/deployment/script' }
-          WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-          WhiskeyDisk.reset
+          WhiskeyDisk.configuration = { 'deploy_to' => '/path/to/main/repo', 'post_deploy_script' => '/path/to/deployment/script' }
         end
         it 'should attempt to run the post deployment script' do
@@ -493,10 +450,7 @@ describe 'WhiskeyDisk' do
       describe 'and the script path does not start with a "/"' do
         before do
-          @parameters = { 'deploy_to'          => '/path/to/main/repo',
-                          'post_deploy_script' => 'path/to/deployment/script' }
-          WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-          WhiskeyDisk.reset
+          WhiskeyDisk.configuration = { 'deploy_to' => '/path/to/main/repo', 'post_deploy_script' => 'path/to/deployment/script' }
         end
         it 'should attempt to run the post deployment script' do
@@ -538,8 +492,7 @@ describe 'WhiskeyDisk' do
     it 'should ensure that any rake ENV variable are set when checking for deploy:post_setup tasks' do
       @parameters = { 'deploy_to' => '/path/to/main/repo', 'rake_env' => { 'RAILS_ENV' => 'production', 'FOO' => 'bar' } }
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters
       WhiskeyDisk.run_post_deploy_hooks
       @parameters['rake_env'].each_pair do |k,v|
         WhiskeyDisk.buffer.join(' ').should.match(%r{#{k}='#{v}' .*rake -P})
@@ -548,8 +501,7 @@ describe 'WhiskeyDisk' do
     it 'should set any rake_env variables when running the rake tasks' do
       @parameters = { 'deploy_to' => '/path/to/main/repo', 'rake_env' => { 'RAILS_ENV' => 'production', 'FOO' => 'bar' } }
-      WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = @parameters
       WhiskeyDisk.run_post_deploy_hooks
       @parameters['rake_env'].each_pair do |k,v|
         WhiskeyDisk.buffer.join(' ').should.match(%r{#{k}='#{v}' })
@@ -560,18 +512,15 @@ describe 'WhiskeyDisk' do
   describe 'flushing changes' do
     describe 'when running remotely' do
       before do
-        @parameters = { 'domain' => 'www.domain.com', 'deploy_to' => '/path/to/main/repo' }
-        WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-        WhiskeyDisk.reset
+        WhiskeyDisk.configuration = { 'domain' => 'www.domain.com', 'deploy_to' => '/path/to/main/repo' }
         WhiskeyDisk.stub!(:bundle).and_return('command string')
-        WhiskeyDisk.stub!(:register_configuration)
         WhiskeyDisk.stub!(:run)
       end
       it 'should bundle the buffer of commands' do
         WhiskeyDisk.enqueue('x')
         WhiskeyDisk.enqueue('y')
-        WhiskeyDisk.should.receive(:bundle).and_return('command string')
+        WhiskeyDisk.should.receive(:bundle)
         WhiskeyDisk.flush
       end
@@ -583,9 +532,7 @@ describe 'WhiskeyDisk' do
     describe 'when running locally' do
       before do
-        @parameters = { 'deploy_to' => '/path/to/main/repo' }
-        WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-        WhiskeyDisk.reset
+        WhiskeyDisk.configuration = { 'deploy_to' => '/path/to/main/repo' }
         WhiskeyDisk.stub!(:bundle).and_return('command string')
         WhiskeyDisk.stub!(:system)
       end
@@ -664,8 +611,7 @@ describe 'WhiskeyDisk' do
             @deploy_to = '/path/to/main/repo'
             @repository = 'git@git://foo.bar.git'
             @parameters = { 'deploy_to' => @deploy_to, 'repository' => @repository }
-            WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-            WhiskeyDisk.reset
+            WhiskeyDisk.configuration = @parameters
             WhiskeyDisk.enable_staleness_checks
           end
@@ -695,8 +641,7 @@ describe 'WhiskeyDisk' do
           end
           it "should query the head of the main checkout's specified branch if a branch is specified" do
-            WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters.merge({'branch' => 'production'}))
-            WhiskeyDisk.reset
+            WhiskeyDisk.configuration = @parameters.merge({'branch' => 'production'})
             WhiskeyDisk.enable_staleness_checks
             WhiskeyDisk.enqueue("COMMAND")
             WhiskeyDisk.bundle.should.match(Regexp.new(Regexp.escape("cd #{@deploy_to}; ml=\`cat .git/refs/heads/production\`;")))
@@ -708,8 +653,7 @@ describe 'WhiskeyDisk' do
           end
           it "should query the head of the main repository's specified branch if a branch is specified" do
-            WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters.merge({'branch' => 'production'}))
-            WhiskeyDisk.reset
+            WhiskeyDisk.configuration = @parameters.merge({'branch' => 'production'})
             WhiskeyDisk.enable_staleness_checks
             WhiskeyDisk.enqueue("COMMAND")
             WhiskeyDisk.bundle.should.match(Regexp.new(Regexp.escape("mr=\`git ls-remote #{@repository} refs/heads/production\`;")))
@@ -731,8 +675,7 @@ describe 'WhiskeyDisk' do
               'deploy_to' => @deploy_to, 'repository' => @repository,
               'deploy_config_to' => @deploy_config_to, 'config_repository' => @config_repository
             }
-            WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters)
-            WhiskeyDisk.reset
+            WhiskeyDisk.configuration = @parameters
             WhiskeyDisk.enable_staleness_checks
           end
@@ -762,8 +705,7 @@ describe 'WhiskeyDisk' do
           end
           it "should query the head of the main checkout's specified branch if a branch is specified" do
-            WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters.merge({'branch' => 'production'}))
-            WhiskeyDisk.reset
+            WhiskeyDisk.configuration = @parameters.merge({'branch' => 'production'})
             WhiskeyDisk.enable_staleness_checks
             WhiskeyDisk.enqueue("COMMAND")
             WhiskeyDisk.bundle.should.match(Regexp.new(Regexp.escape("cd #{@deploy_to}; ml=\`cat .git/refs/heads/production\`;")))
@@ -775,8 +717,7 @@ describe 'WhiskeyDisk' do
           end
           it "should query the head of the main repository's specified branch if a branch is specified" do
-            WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters.merge({'branch' => 'production'}))
-            WhiskeyDisk.reset
+            WhiskeyDisk.configuration = @parameters.merge({'branch' => 'production'})
             WhiskeyDisk.enable_staleness_checks
             WhiskeyDisk.enqueue("COMMAND")
             WhiskeyDisk.bundle.should.match(Regexp.new(Regexp.escape("mr=\`git ls-remote #{@repository} refs/heads/production\`;")))
@@ -788,8 +729,7 @@ describe 'WhiskeyDisk' do
           end
           it "should query the head of the config checkout's specified branch if a branch is specified" do
-            WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters.merge({'config_branch' => 'production'}))
-            WhiskeyDisk.reset
+            WhiskeyDisk.configuration = @parameters.merge({'config_branch' => 'production'})
             WhiskeyDisk.enable_staleness_checks
             WhiskeyDisk.enqueue("COMMAND")
             WhiskeyDisk.bundle.should.match(Regexp.new(Regexp.escape("cd #{@deploy_config_to}; cl=\`cat .git/refs/heads/production\`;")))
@@ -801,8 +741,7 @@ describe 'WhiskeyDisk' do
           end
           it "should query the head of the config repository's specified branch if a branch is specified" do
-            WhiskeyDisk::Config.stub!(:fetch).and_return(@parameters.merge({'config_branch' => 'production'}))
-            WhiskeyDisk.reset
+            WhiskeyDisk.configuration = @parameters.merge({'config_branch' => 'production'})
             WhiskeyDisk.enable_staleness_checks
             WhiskeyDisk.enqueue("COMMAND")
             WhiskeyDisk.bundle.should.match(Regexp.new(Regexp.escape("cr=\`git ls-remote #{@config_repository} refs/heads/production\`;")))
@@ -815,8 +754,7 @@ describe 'WhiskeyDisk' do
   describe 'when running a command string remotely' do
     before do
       @domain = 'ogc@ogtastic.com'
-      WhiskeyDisk::Config.stub!(:fetch).and_return({ 'domain' => @domain })
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = { 'domain' => @domain }
       WhiskeyDisk.stub!(:system)
     end
@@ -829,8 +767,7 @@ describe 'WhiskeyDisk' do
     end
     it 'should fail if the domain path is not specified' do
-      WhiskeyDisk::Config.stub!(:fetch).and_return({})
-      WhiskeyDisk.reset
+      WhiskeyDisk.configuration = {}
       lambda { WhiskeyDisk.run('ls') }.should.raise
     end

data/whiskey_disk.gemspec CHANGED Viewed

@@ -5,11 +5,11 @@
 Gem::Specification.new do |s|
   s.name = %q{whiskey_disk}
-  s.version = "0.5.3"
+  s.version = "0.5.4"
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Rick Bradley"]
-  s.date = %q{2010-09-07}
+  s.date = %q{2010-10-26}
   s.default_executable = %q{wd}
   s.description = %q{Opinionated gem for doing fast git-based server deployments.}
   s.email = %q{rick@rickbradley.com}

metadata CHANGED Viewed

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: whiskey_disk
 version: !ruby/object:Gem::Version
-  hash: 13
+  hash: 3
   prerelease: false
   segments:
   - 0
   - 5
-  - 3
-  version: 0.5.3
+  - 4
+  version: 0.5.4
 platform: ruby
 authors:
 - Rick Bradley
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
-date: 2010-09-07 00:00:00 -05:00
+date: 2010-10-26 00:00:00 -05:00
 default_executable: wd
 dependencies:
 - !ruby/object:Gem::Dependency