whiskey_disk 0.6.4 → 0.6.10

data/spec/whiskey_disk/config_spec.rb

@@ -19,6 +19,17 @@ def write_config_file(data)
   File.open(@config_file, 'w') { |f| f.puts YAML.dump(data) }
 end
 
+# class for testing .open calls -- for use with URL config paths
+class TestURLConfig < WhiskeyDisk::Config
+  def self.open
+    raise
+  end
+end
+
+def set_config_url_response(data)
+  TestURLConfig.stub!(:open).and_return(YAML.dump(data))
+end
+
 describe WhiskeyDisk::Config do
   describe 'when computing the environment name' do
     it 'should return false when there is no ENV["to"] setting' do
@@ -78,98 +89,202 @@ describe WhiskeyDisk::Config do
       WhiskeyDisk::Config.check_staleness?.should == true
     end
   end
+  
+  describe 'when determining whether there is a domain limit set' do
+    it 'should return false when ENV["only"] is nil' do
+      ENV['only'] = nil
+      WhiskeyDisk::Config.domain_limit.should == false
+    end
+    
+    it 'should return false when ENV["only"] is empty' do
+      ENV['only'] = ''
+      WhiskeyDisk::Config.domain_limit.should == false
+    end
+    
+    it 'should return the value in ENV["only"] when it is non-empty' do
+      ENV['only'] = 'somedomain'
+      WhiskeyDisk::Config.domain_limit.should == 'somedomain'      
+    end
+  end
 
   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
+    describe 'and path specified is an URL' do
+      before do
+        ENV['to'] = @env = 'foo:staging'
+        ENV['path'] = 'https://www.example.com/foo/bar/deploy.yml'
+      end
+      
+      it 'should fail if the current environment cannot be determined' do
+        ENV['to'] = nil
+        lambda { TestURLConfig.fetch }.should.raise
+      end
 
-    after do
-      FileUtils.rm_rf(@path)
-    end
+      it 'should fail if the configuration data cannot be retrieved' do
+        TestURLConfig.stub!(:open).and_raise(RuntimeError)
+        lambda { TestURLConfig.fetch }.should.raise
+      end
 
-    it 'should fail if the current environment cannot be determined' do
-      ENV['to'] = nil
-      lambda { WhiskeyDisk::Config.fetch }.should.raise
-    end
+      it 'should fail if the retrieved configuration data is invalid' do
+        TestURLConfig.stub!(:open).and_return("}")
+        lambda { TestURLConfig.fetch }.should.raise
+      end
 
-    it 'should fail if the configuration file does not exist' do
-      lambda { WhiskeyDisk::Config.fetch }.should.raise
-    end
+      it 'should fail if the retrieved configuration data does not define data for this environment' do
+        set_config_url_response('foo' => { 'production' => { 'a' => 'b'} })
+        lambda { TestURLConfig.fetch }.should.raise
+      end
 
-    it 'should fail if the configuration file cannot be read' do
-      Dir.mkdir(File.join(@path, 'tmp'))
-      lambda { WhiskeyDisk::Config.fetch }.should.raise
-    end
+      it 'should return the retrieved configuration yaml data for this environment as a hash' do
+        staging = { 'foo' => 'bar', 'repository' => 'xyzzy' }
+        set_config_url_response('foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging })
+        result = TestURLConfig.fetch
+        staging.each_pair do |k,v|
+          result[k].should == v
+        end
+      end
+    
+      it 'should not include configuration information for other environments in the returned hash' do
+        staging = { 'foo' => 'bar', 'baz' => 'xyzzy' }
+        set_config_url_response('production' => { 'repository' => 'c', 'a' => 'b'}, 'staging' => staging)
+        TestURLConfig.fetch['a'].should.be.nil
+      end
 
-    it 'should fail if the configuration file is invalid' do
-      File.open(@config_file, 'w') {|f| f.puts "}" }
-      lambda { WhiskeyDisk::Config.fetch }.should.raise
-    end
+      it 'should include the environment in the hash' do
+        staging = { 'foo' => 'bar', 'baz' => 'xyzzy' }
+        set_config_url_response('foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging })
+        TestURLConfig.fetch['environment'].should == 'staging'
+      end
 
-    it 'should fail if the configuration file does not define data for this environment' do
-      write_config_file('foo' => { 'production' => { 'a' => 'b'} })
-      lambda { WhiskeyDisk::Config.fetch }.should.raise
-    end
+      it 'should not allow overriding the environment in the configuration file' do
+        staging = { 'foo' => 'bar', 'repository' => 'xyzzy', 'environment' => 'production' }
+        set_config_url_response('foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging })
+        TestURLConfig.fetch['environment'].should == 'staging'
+      end
 
-    it 'should return the configuration yaml file data for this environment as a hash' do
-      staging = { 'foo' => 'bar', 'repository' => 'xyzzy' }
-      write_config_file('foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging })
-      result = WhiskeyDisk::Config.fetch
-      staging.each_pair do |k,v|
-        result[k].should == v
+      it 'should include the project handle in the hash' do
+        staging = { 'foo' => 'bar', 'repository' => 'xyzzy' }
+        set_config_url_response('foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging })
+        TestURLConfig.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' }
+        set_config_url_response('foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging })
+        TestURLConfig.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' }
+        set_config_url_response('production' => { 'repository' => 'b'}, 'staging' => staging)
+        TestURLConfig.fetch['project'].should == 'diskey_whisk'
       end
-    end
     
-    it 'should not include configuration information for other environments in the returned hash' do
-      staging = { 'foo' => 'bar', 'baz' => 'xyzzy' }
-      write_config_file('production' => { 'repository' => 'c', 'a' => 'b'}, 'staging' => staging)
-      WhiskeyDisk::Config.fetch['a'].should.be.nil
+      it 'should include the environment name as the config_target setting when no config_target is specified' do
+        staging = { 'foo' => 'bar', 'repository' => 'xyzzy', 'project' => 'diskey_whisk' }
+        set_config_url_response('production' => { 'repository' => 'b'}, 'staging' => staging)
+        TestURLConfig.fetch['config_target'].should == 'staging'
+      end
+    
+      it 'should include the config_target setting when a config_target is specified' do
+        staging = { 'foo' => 'bar', 'repository' => 'xyzzy', 'project' => 'diskey_whisk', 'config_target' => 'testing' }
+        set_config_url_response('production' => { 'repository' => 'b'}, 'staging' => staging)
+        TestURLConfig.fetch['config_target'].should == 'testing'
+      end
     end
+    
+    describe 'and path specified is not an URL' do
+      before do
+        ENV['to'] = @env = 'foo:staging'
+        @path = build_temp_dir
+        ENV['path'] = @config_file = File.join(@path, 'deploy.yml')
+      end
 
-    it 'should include the environment in the hash' do
-      staging = { 'foo' => 'bar', 'baz' => 'xyzzy' }
-      write_config_file('foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging })
-      WhiskeyDisk::Config.fetch['environment'].should == 'staging'
-    end
+      after do
+        FileUtils.rm_rf(@path)
+      end
 
-    it 'should not allow overriding the environment in the configuration file' do
-      staging = { 'foo' => 'bar', 'repository' => 'xyzzy', 'environment' => 'production' }
-      write_config_file('foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging })
-      WhiskeyDisk::Config.fetch['environment'].should == 'staging'
-    end
+      it 'should fail if the current environment cannot be determined' do
+        ENV['to'] = nil
+        lambda { WhiskeyDisk::Config.fetch }.should.raise
+      end
 
-    it 'should include the project handle in the hash' do
-      staging = { 'foo' => 'bar', 'repository' => 'xyzzy' }
-      write_config_file('foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging })
-      WhiskeyDisk::Config.fetch['project'].should == 'foo'
-    end
+      it 'should fail if the configuration file does not exist' do
+        lambda { WhiskeyDisk::Config.fetch }.should.raise
+      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' }
-      write_config_file('foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging })
-      WhiskeyDisk::Config.fetch['project'].should == 'foo'
-    end
+      it 'should fail if the configuration file cannot be read' do
+        Dir.mkdir(File.join(@path, 'tmp'))
+        lambda { WhiskeyDisk::Config.fetch }.should.raise
+      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' }
-      write_config_file('production' => { 'repository' => 'b'}, 'staging' => staging)
-      WhiskeyDisk::Config.fetch['project'].should == 'diskey_whisk'
-    end
+      it 'should fail if the configuration file is invalid' do
+        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
+        write_config_file('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' }
+        write_config_file('foo' => { 'production' => { 'repository' => 'b'}, 'staging' => staging })
+        result = WhiskeyDisk::Config.fetch
+        staging.each_pair do |k,v|
+          result[k].should == v
+        end
+      end
     
-    it 'should include the environment name as the config_target setting when no config_target is specified' do
-      staging = { 'foo' => 'bar', 'repository' => 'xyzzy', 'project' => 'diskey_whisk' }
-      write_config_file('production' => { 'repository' => 'b'}, 'staging' => staging)
-      WhiskeyDisk::Config.fetch['config_target'].should == 'staging'
-    end
+      it 'should not include configuration information for other environments in the returned hash' do
+        staging = { 'foo' => 'bar', 'baz' => 'xyzzy' }
+        write_config_file('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' }
+        write_config_file('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' }
+        write_config_file('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' }
+        write_config_file('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' }
+        write_config_file('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' }
+        write_config_file('production' => { 'repository' => 'b'}, 'staging' => staging)
+        WhiskeyDisk::Config.fetch['project'].should == 'diskey_whisk'
+      end
     
-    it 'should include the config_target setting when a config_target is specified' do
-      staging = { 'foo' => 'bar', 'repository' => 'xyzzy', 'project' => 'diskey_whisk', 'config_target' => 'testing' }
-      write_config_file('production' => { 'repository' => 'b'}, 'staging' => staging)
-      WhiskeyDisk::Config.fetch['config_target'].should == 'testing'
+      it 'should include the environment name as the config_target setting when no config_target is specified' do
+        staging = { 'foo' => 'bar', 'repository' => 'xyzzy', 'project' => 'diskey_whisk' }
+        write_config_file('production' => { 'repository' => 'b'}, 'staging' => staging)
+        WhiskeyDisk::Config.fetch['config_target'].should == 'staging'
+      end
+    
+      it 'should include the config_target setting when a config_target is specified' do
+        staging = { 'foo' => 'bar', 'repository' => 'xyzzy', 'project' => 'diskey_whisk', 'config_target' => 'testing' }
+        write_config_file('production' => { 'repository' => 'b'}, 'staging' => staging)
+        WhiskeyDisk::Config.fetch['config_target'].should == 'testing'
+      end
     end
   end
 
@@ -215,7 +330,7 @@ describe WhiskeyDisk::Config do
 
     it 'should return a normalized version of the un-YAMLized configuration data' do
       write_config_file('repository' => 'x')
-      WhiskeyDisk::Config.load_data.should == { 'foo' => { 'bar' => { 'repository' => 'x' } } }
+      WhiskeyDisk::Config.load_data.should == { 'foo' => { 'bar' => { 'repository' => 'x', 'domain' => [{ :name => 'local' } ] } } }
     end
     
     describe 'normalizing domains' do
@@ -226,7 +341,8 @@ describe WhiskeyDisk::Config do
             'eee' => { 'repository' => 'x', 'domain' => '' },
             'abc' => { 'repository' => 'x', 'domain' => 'what@example.com' },
             'baz' => { 'repository' => 'x', 'domain' => [ 'bar@example.com', 'baz@domain.com' ]},
-            'bar' => { 'repository' => 'x', 'domain' => [ 'user@example.com', nil, 'foo@domain.com', '' ]},
+            'bar' => { 'repository' => 'x', 'domain' => [ 'user@example.com', nil, 'foo@domain.com' ]},
+            'bat' => { 'repository' => 'x', 'domain' => [ 'user@example.com', 'foo@domain.com', '' ]},
             'hsh' => { 'repository' => 'x', 'domain' => [ { 'name' => 'bar@example.com' }, { 'name' => 'baz@domain.com' } ]},
             'mix' => { 'repository' => 'x', 'domain' => [ { 'name' => 'bar@example.com' }, 'baz@domain.com' ]},            
             'erl' => { 'repository' => 'x', 'domain' => [ { 'name' => 'bar@example.com', 'roles' => nil }, 
@@ -237,7 +353,7 @@ describe WhiskeyDisk::Config do
                                                           { 'name' => 'aok@domain.com', 'roles' => 'app' } ]},            
             'wow' => { 'repository' => 'x', 'domain' => [ { 'name' => 'bar@example.com', 'roles' => [ 'web', 'db' ] }, 
                                                           { 'name' => 'baz@domain.com', 'roles' => [ 'db' ] },   
-                                                          nil, '', [], 'foo@bar.example.com',      
+                                                            '', 'foo@bar.example.com',      
                                                           { 'name' => 'aok@domain.com', 'roles' => 'app' } ]},            
           },
 
@@ -246,7 +362,8 @@ describe WhiskeyDisk::Config do
             'eee' => { 'repository' => 'x', 'domain' => '' },
             'abc' => { 'repository' => 'x', 'domain' => 'what@example.com' },
             'hij' => { 'repository' => 'x', 'domain' => [ 'bar@example.com', 'baz@domain.com' ]},
-            'def' => { 'repository' => 'x', 'domain' => [ 'user@example.com', nil, 'foo@domain.com', '' ]},
+            'def' => { 'repository' => 'x', 'domain' => [ 'user@example.com', nil, 'foo@domain.com' ]},
+            'dex' => { 'repository' => 'x', 'domain' => [ 'user@example.com', 'foo@domain.com', '' ]},
             'hsh' => { 'repository' => 'x', 'domain' => [ { 'name' => 'bar@example.com' }, { 'name' => 'baz@domain.com' } ]},
             'mix' => { 'repository' => 'x', 'domain' => [ { 'name' => 'bar@example.com' }, 'baz@domain.com' ]},
             'erl' => { 'repository' => 'x', 'domain' => [ { 'name' => 'bar@example.com', 'roles' => nil }, 
@@ -257,26 +374,26 @@ describe WhiskeyDisk::Config do
                                                           { 'name' => 'aok@domain.com', 'roles' => 'app' } ]},            
             'wow' => { 'repository' => 'x', 'domain' => [ { 'name' => 'bar@example.com', 'roles' => [ 'web', 'db' ] }, 
                                                           { 'name' => 'baz@domain.com', 'roles' => [ 'db' ] },   
-                                                          nil, '', [], 'foo@bar.example.com',      
+                                                             '', 'foo@bar.example.com',      
                                                           { 'name' => 'aok@domain.com', 'roles' => 'app' } ]},            
           }
         )
       end
     
-      it 'should leave the domain as nil when no domain is specified' do
-        WhiskeyDisk::Config.load_data['foo']['xyz']['domain'].should.be.nil     
+      it 'should set the domain to "local" when no domain is specified' do
+        WhiskeyDisk::Config.load_data['foo']['xyz']['domain'].should == [ { :name => 'local' } ]   
       end
       
       it 'should handle nil domains across all projects and targets' do
-        WhiskeyDisk::Config.load_data['zyx']['xyz']['domain'].should.be.nil     
+        WhiskeyDisk::Config.load_data['zyx']['xyz']['domain'].should == [ { :name => 'local' } ]
       end
     
-      it 'should return domain as nil if a single empty domain was specified' do
-        WhiskeyDisk::Config.load_data['foo']['eee']['domain'].should.be.nil       
+      it 'should return domain as "local" if a single empty domain was specified' do
+        WhiskeyDisk::Config.load_data['foo']['eee']['domain'].should == [ { :name => 'local' } ]
       end
       
       it 'should handle single empty specified domains across all projects and targets' do
-        WhiskeyDisk::Config.load_data['zyx']['eee']['domain'].should.be.nil                 
+        WhiskeyDisk::Config.load_data['zyx']['eee']['domain'].should == [ { :name => 'local' } ]                 
       end
       
       it 'should return domain as a single element list with a name if a single non-empty domain was specified' do
@@ -295,19 +412,31 @@ describe WhiskeyDisk::Config do
     
       it 'should handle lists of domains across all projects and targets' do
         WhiskeyDisk::Config.load_data['zyx']['hij']['domain'].should == [ 
-          { :name => 'bar@example.com' }, { :name => 'baz@domain.com' }
+          { :name => 'bar@example.com' }, { :name => 'baz@domain.com' } 
          ]
       end
       
-      it 'should remove any blank or nil domains from a simple list of domains' do
+      it 'should replace any nil domains with "local" domains in a domain list' do
         WhiskeyDisk::Config.load_data['foo']['bar']['domain'].should == [
-          { :name => 'user@example.com' }, { :name => 'foo@domain.com' }
+          { :name => 'user@example.com' }, { :name => 'local' }, { :name => 'foo@domain.com' }
          ]
       end
   
-      it 'should handle cleaning up blanks and nils across all projects and targets' do
+      it 'should handle localizing nils across all projects and targets' do
         WhiskeyDisk::Config.load_data['zyx']['def']['domain'].should == [
-          { :name => 'user@example.com' }, { :name => 'foo@domain.com' }
+          { :name => 'user@example.com' }, { :name => 'local' }, { :name => 'foo@domain.com' }
+         ]
+      end
+      
+      it 'should replace any blank domains with "local" domains in a domain list' do
+        WhiskeyDisk::Config.load_data['foo']['bat']['domain'].should == [
+          { :name => 'user@example.com' }, { :name => 'foo@domain.com' }, { :name => 'local' }
+         ]
+      end
+  
+      it 'should handle localizing blanks across all projects and targets' do
+        WhiskeyDisk::Config.load_data['zyx']['dex']['domain'].should == [
+          { :name => 'user@example.com' }, { :name => 'foo@domain.com' }, { :name => 'local' }
          ]
       end
       
@@ -343,6 +472,7 @@ describe WhiskeyDisk::Config do
         WhiskeyDisk::Config.load_data['foo']['wow']['domain'].should == [
           { :name => 'bar@example.com', :roles => [ 'web', 'db' ] }, 
           { :name => 'baz@domain.com',  :roles => [ 'db' ] }, 
+          { :name => 'local' },
           { :name => 'foo@bar.example.com' },
           { :name => 'aok@domain.com',  :roles => [ 'app' ] }
          ]                
@@ -352,10 +482,24 @@ describe WhiskeyDisk::Config do
         WhiskeyDisk::Config.load_data['zyx']['wow']['domain'].should == [
           { :name => 'bar@example.com', :roles => [ 'web', 'db' ] }, 
           { :name => 'baz@domain.com',  :roles => [ 'db' ] }, 
+          { :name => 'local' },
           { :name => 'foo@bar.example.com' },
           { :name => 'aok@domain.com',  :roles => [ 'app' ] }
          ]        
       end
+      
+      it 'should raise an exception if a domain appears more than once in a target' do
+        write_config_file(
+          'foo' => { 
+            'erl' => { 'repository' => 'x', 'domain' => [ { 'name' => 'bar@example.com', 'roles' => nil }, 
+                                                          { 'name' => 'baz@domain.com', 'roles' => '' },
+                                                          { 'name' => 'bar@example.com', 'roles' => [] } ]},
+          }
+        )
+        
+        lambda { WhiskeyDisk::Config.load_data }.should.raise
+        
+      end
     end
   end
 

data/spec/whiskey_disk/rake_spec.rb

@@ -34,17 +34,6 @@ describe 'rake tasks' do
       WhiskeyDisk.stub!(:success?).and_return(true)
     end
     
-    it 'should make changes on the specified domain when a domain is specified' do
-      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
-      WhiskeyDisk.configuration = { 'domain' => nil }
-      WhiskeyDisk.should.not.be.remote
-    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)
       @rake["deploy:setup"].invoke
@@ -163,16 +152,6 @@ describe 'rake tasks' do
       WhiskeyDisk.stub!(:success?).and_return(true)
     end
     
-    it 'should make changes on the specified domain when a domain is specified' do
-      WhiskeyDisk.configuration = { 'domain' => [ 'some domain' ]}
-      @rake["deploy:now"].invoke
-      WhiskeyDisk.should.be.remote
-    end
-    
-    it 'should make changes on the local system when no domain is specified' do
-      WhiskeyDisk.should.not.be.remote
-    end
-    
     it 'should enable staleness checks' do
       WhiskeyDisk.should.receive(:enable_staleness_checks)
       @rake["deploy:now"].invoke