capistrano 3.0.1 → 3.1.0

data/spec/lib/capistrano/application_spec.rb

@@ -7,11 +7,10 @@ describe Capistrano::Application do
   it "provides a --format option which enables the choice of output formatting"
 
   it "identifies itself as cap and not rake" do
-    pending "Waiting for: https://github.com/jimweirich/rake/pull/204"
     out, _ = capture_io do
       flags '--help', '-h'
     end
-    out.should match(/\bcap [ -f capfile ]\b/)
+    out.lines.first.should match(/cap \[-f rakefile\]/)
   end
 
   it "overrides the rake method, but still prints the rake version" do
@@ -37,9 +36,7 @@ describe Capistrano::Application do
     def subject.exit(*args)
       throw(:system_exit, :exit)
     end
-    subject.instance_eval do
-      handle_options
-    end
+    subject.run
     subject.options
   end
 

data/spec/lib/capistrano/configuration/server_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 module Capistrano
   class Configuration
     describe Server do
-      let(:server) { Server.new('hostname') }
+      let(:server) { Server.new('hostname:1234') }
 
       describe 'adding a role' do
         subject { server.add_role(:test) }
@@ -33,18 +33,23 @@ module Capistrano
       end
 
       describe 'comparing identity' do
-        subject { server.matches? hostname }
+        subject { server.matches? Server[hostname] }
 
         context 'with the same hostname' do
-          let(:hostname) { 'hostname' }
+          let(:hostname) { 'hostname:1234' }
           it { should be_true }
         end
 
         context 'with the same hostname and a user' do
-          let(:hostname) { 'user@hostname' }
+          let(:hostname) { 'user@hostname:1234' }
           it { should be_true }
         end
 
+        context 'with the same hostname but different port' do
+          let(:hostname) { 'hostname:5678' }
+          it { should be_false }
+        end
+
         context 'with a different hostname' do
           let(:hostname) { 'otherserver' }
           it { should be_false }
@@ -159,6 +164,11 @@ module Capistrano
               let(:options) { { select: :active }}
               it { should be_true }
             end
+
+            context 'with :exclude' do
+              let(:options) { { exclude: :active }}
+              it { should be_false }
+            end
           end
 
           context 'value does not match server properly' do
@@ -171,6 +181,11 @@ module Capistrano
               let(:options) { { select: :inactive }}
               it { should be_false }
             end
+
+            context 'with :exclude' do
+              let(:options) { { exclude: :inactive }}
+              it { should be_true }
+            end
           end
         end
 
@@ -186,6 +201,12 @@ module Capistrano
               let(:options) { { select: ->(s) { s.properties.active } } }
               it { should be_true }
             end
+
+            context 'with :exclude' do
+              let(:options) { { exclude: ->(s) { s.properties.active } } }
+              it { should be_false }
+            end
+
           end
 
           context 'value does not match server properly' do
@@ -198,6 +219,12 @@ module Capistrano
               let(:options) { { select: ->(s) { s.properties.inactive } } }
               it { should be_false }
             end
+
+            context 'with :exclude' do
+              let(:options) { { exclude: ->(s) { s.properties.inactive } } }
+              it { should be_true }
+            end
+
           end
         end
 
@@ -244,6 +271,15 @@ module Capistrano
 
       end
 
+      describe ".[]" do
+        it 'creates a server if its argument is not already a server' do
+          expect(Server['hostname:1234']).to be_a Server
+        end
+
+        it 'returns its argument if it is already a server' do
+          expect(Server[server]).to be server
+        end
+      end
     end
   end
 end

data/spec/lib/capistrano/configuration/servers/host_filter_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+module Capistrano
+  class Configuration
+    class Servers
+
+      describe HostFilter do
+        let(:host_filter) { HostFilter.new(available) }
+        let(:available) { [ Server.new('server1'), Server.new('server2'), Server.new('server3') ] }
+
+        describe '#new' do
+          it 'takes one array of hostnames' do
+            expect(host_filter)
+          end
+        end
+
+        describe '.for' do
+
+          subject { HostFilter.for(available) }
+
+          context 'without env vars' do
+            it 'returns all available hosts' do
+              expect(subject).to eq available
+            end
+          end
+
+          context 'with ENV vars' do
+            before do
+              ENV.stubs(:[]).with('HOSTS').returns('server1,server2')
+            end
+
+            it 'returns all required hosts defined in HOSTS' do
+              expect(subject).to eq [Server.new('server1'), Server.new('server2')]
+            end
+          end
+
+          context 'with configuration filters' do
+            before do
+              Configuration.env.set(:filter, hosts: %w{server1 server2})
+            end
+
+            it 'returns all required hosts defined in the filter' do
+              expect(subject).to eq [Server.new('server1'), Server.new('server2')]
+            end
+
+            after do
+              Configuration.env.delete(:filter)
+            end
+          end
+
+          context 'with a single configuration filter' do
+            before do
+              Configuration.env.set(:filter, hosts: 'server3')
+            end
+
+            it 'returns all required hosts defined in the filter' do
+              expect(subject).to eq [Server.new('server3')]
+            end
+
+            after do
+              Configuration.env.delete(:filter)
+            end
+          end
+
+          context 'with configuration filters and ENV vars' do
+            before do
+              Configuration.env.set(:filter, hosts: 'server1')
+              ENV.stubs(:[]).with('HOSTS').returns('server3')
+            end
+
+            it 'returns all required hosts defined in the filter' do
+              expect(subject).to eq [Server.new('server1'), Server.new('server3')]
+            end
+
+            after do
+              Configuration.env.delete(:filter)
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/lib/capistrano/configuration/servers_spec.rb

@@ -106,6 +106,11 @@ module Capistrano
           expect(servers.roles_for([:all]).first.properties.test).to eq :value
         end
 
+        it 'can accept multiple servers with the same hostname but different ports' do
+          servers.add_host('2', roles: [:app, 'web'], test: :value, port: 12)
+          servers.add_host('2', roles: [:app, 'web'], test: :value, port: 34)
+          expect(servers.count { |server| server.hostname == '2' }).to eq 2
+        end
       end
 
       describe 'selecting roles' do
@@ -141,10 +146,40 @@ module Capistrano
 
       end
 
+      describe 'excluding by property' do
+
+        before do
+          servers.add_host('1', roles: :app, active: true)
+          servers.add_host('2', roles: :app, active: true, no_release: true)
+        end
+
+        it 'is empty if the filter would remove all matching hosts' do
+          hosts = servers.roles_for([:app, exclude: :active])
+          expect(hosts.map(&:hostname)).to be_empty
+        end
+
+        it 'returns the servers without the attributes specified' do
+          hosts = servers.roles_for([:app, exclude: :no_release])
+          expect(hosts.map(&:hostname)).to eq %w{1}
+        end
+
+        it 'can exclude hosts by properties on the host using a regular proc' do
+          hosts = servers.roles_for([:app, exclude: ->(h) { h.properties.no_release }])
+          expect(hosts.map(&:hostname)).to eq %w{1}
+        end
+
+        it 'is empty if the regular proc filter would remove all matching hosts' do
+          hosts = servers.roles_for([:app, exclude: ->(h) { h.properties.active }])
+          expect(hosts.map(&:hostname)).to be_empty
+        end
+
+      end
+
       describe 'filtering roles' do
 
         before do
           ENV.stubs(:[]).with('ROLES').returns('web,db')
+          ENV.stubs(:[]).with('HOSTS').returns(nil)
           servers.add_host('1', roles: :app, active: true)
           servers.add_host('2', roles: :app)
           servers.add_host('3', roles: :web)

data/spec/lib/capistrano/configuration_spec.rb

@@ -12,6 +12,14 @@ module Capistrano
       end
     end
 
+    describe '.reset!' do
+      it 'blows away the existing `env` and creates a new one' do
+        old_env = Configuration.env
+        Configuration.reset!
+        expect(Configuration.env).not_to be old_env
+      end
+    end
+
     describe 'roles' do
       context 'adding a role' do
         subject { config.role(:app, %w{server1 server2}) }

data/spec/lib/capistrano/dsl_spec.rb

@@ -20,17 +20,6 @@ module Capistrano
       end
     end
 
-    describe '#stages' do
-      before do
-        Dir.expects(:[]).with('config/deploy/*.rb').
-          returns(['config/deploy/staging.rb', 'config/deploy/production.rb'])
-      end
-
-      it 'returns a list of defined stages' do
-        expect(dsl.stages).to eq %w{staging production}
-      end
-    end
-
     describe '#stage_set?' do
       subject { dsl.stage_set? }
 

data/spec/lib/capistrano/git_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+require 'capistrano/git'
+
+module Capistrano
+  describe Git do
+    let(:context) { Class.new.new }
+    subject { Capistrano::Git.new(context, Capistrano::Git::DefaultStrategy) }
+
+    describe "#git" do
+      it "should call execute git in the context, with arguments" do
+        context.expects(:execute).with(:git, :init)
+        subject.git(:init)
+      end
+    end
+  end
+
+  describe Git::DefaultStrategy do
+    let(:context) { Class.new.new }
+    subject { Capistrano::Git.new(context, Capistrano::Git::DefaultStrategy) }
+
+    describe "#test" do
+      it "should call test for repo HEAD" do
+        context.expects(:repo_path).returns("/path/to/repo")
+        context.expects(:test).with " [ -f /path/to/repo/HEAD ] "
+
+        subject.test
+      end
+    end
+
+    describe "#check" do
+      it "should test the repo url" do
+        context.expects(:repo_url).returns(:url)
+        context.expects(:test).with(:git, :'ls-remote', :url).returns(true)
+
+        subject.check
+      end
+    end
+
+    describe "#clone" do
+      it "should run git clone" do
+        context.expects(:repo_url).returns(:url)
+        context.expects(:repo_path).returns(:path)
+
+        context.expects(:execute).with(:git, :clone, '--mirror', :url, :path)
+
+        subject.clone
+      end
+    end
+
+    describe "#update" do
+      it "should run git update" do
+        context.expects(:execute).with(:git, :remote, :update)
+
+        subject.update
+      end
+    end
+
+    describe "#release" do
+      it "should run git archive" do
+        context.expects(:fetch).returns(:branch)
+        context.expects(:release_path).returns(:path)
+
+        context.expects(:execute).with(:git, :archive, :branch, '| tar -x -C', :path)
+
+        subject.release
+      end
+    end
+  end
+end

data/spec/lib/capistrano/hg_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+require 'capistrano/hg'
+
+module Capistrano
+  describe Hg do
+    let(:context) { Class.new.new }
+    subject { Capistrano::Hg.new(context, Capistrano::Hg::DefaultStrategy) }
+
+    describe "#hg" do
+      it "should call execute hg in the context, with arguments" do
+        context.expects(:execute).with(:hg, :init)
+        subject.hg(:init)
+      end
+    end
+  end
+
+  describe Hg::DefaultStrategy do
+    let(:context) { Class.new.new }
+    subject { Capistrano::Hg.new(context, Capistrano::Hg::DefaultStrategy) }
+
+    describe "#test" do
+      it "should call test for repo HEAD" do
+        context.expects(:repo_path).returns("/path/to/repo")
+        context.expects(:test).with " [ -d /path/to/repo/.hg ] "
+
+        subject.test
+      end
+    end
+
+    describe "#check" do
+      it "should test the repo url" do
+        context.expects(:repo_url).returns(:url)
+        context.expects(:execute).with(:hg, "id", :url)
+
+        subject.check
+      end
+    end
+
+    describe "#clone" do
+      it "should run hg clone" do
+        context.expects(:repo_url).returns(:url)
+        context.expects(:repo_path).returns(:path)
+
+        context.expects(:execute).with(:hg, "clone", '--noupdate', :url, :path)
+
+        subject.clone
+      end
+    end
+
+    describe "#update" do
+      it "should run hg update" do
+        context.expects(:execute).with(:hg, "pull")
+
+        subject.update
+      end
+    end
+
+    describe "#release" do
+      it "should run hg archive" do
+        context.expects(:fetch).returns(:branch)
+        context.expects(:release_path).returns(:path)
+
+        context.expects(:execute).with(:hg, "archive", :path, "--rev", :branch)
+
+        subject.release
+      end
+    end
+  end
+end

data/spec/lib/capistrano/scm_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+require 'capistrano/scm'
+
+module RaiseNotImplementedMacro
+  def raise_not_implemented_on(method)
+    it "should raise NotImplemented on #{method}" do
+      expect {
+        subject.send(method)
+      }.to raise_error(NotImplementedError)
+    end
+  end
+end
+
+RSpec.configure do
+  include RaiseNotImplementedMacro
+end
+
+module DummyStrategy
+  def test
+    test!("you dummy!")
+  end
+end
+
+module BlindStrategy; end
+
+module Capistrano
+  describe SCM do
+    let(:context) { Class.new.new }
+
+    describe "#initialize" do
+      subject { Capistrano::SCM.new(context, DummyStrategy) }
+
+      it "should load the provided strategy" do
+        context.expects(:test).with("you dummy!")
+        subject.test
+      end
+    end
+
+    describe "Convenience methods" do
+      subject { Capistrano::SCM.new(context, BlindStrategy) }
+
+      describe "#test!" do
+        it "should return call test on the context" do
+          context.expects(:test).with(:x)
+          subject.test!(:x)
+        end
+      end
+
+      describe "#repo_url" do
+        it "should return the repo url according to the context" do
+          context.expects(:repo_url).returns(:url)
+          subject.repo_url.should == :url
+        end
+      end
+
+      describe "#repo_path" do
+        it "should return the repo path according to the context" do
+          context.expects(:repo_path).returns(:path)
+          subject.repo_path.should == :path
+        end
+      end
+
+      describe "#release_path" do
+        it "should return the release path according to the context" do
+          context.expects(:release_path).returns('/path/to/nowhere')
+          subject.release_path.should == '/path/to/nowhere'
+        end
+      end
+
+      describe "#fetch" do
+        it "should call fetch on the context" do
+          context.expects(:fetch)
+          subject.fetch(:branch)
+        end
+      end
+    end
+
+    describe "With a 'blind' strategy" do
+      subject { Capistrano::SCM.new(context, BlindStrategy) }
+
+      describe "#test" do
+        raise_not_implemented_on(:test)
+      end
+
+      describe "#check" do
+        raise_not_implemented_on(:check)
+      end
+
+      describe "#clone" do
+        raise_not_implemented_on(:clone)
+      end
+
+      describe "#update" do
+        raise_not_implemented_on(:update)
+      end
+
+      describe "#release" do
+        raise_not_implemented_on(:release)
+      end
+    end
+  end
+end
+