capistrano 3.2.1 → 3.3.3

data/lib/capistrano/upload_task.rb

@@ -0,0 +1,9 @@
+require 'rake/file_creation_task'
+
+module Capistrano
+  class UploadTask < Rake::FileCreationTask
+    def needed?
+      true # always needed because we can't check remote hosts
+    end
+  end
+end

data/lib/capistrano/version.rb

@@ -1,3 +1,3 @@
 module Capistrano
-  VERSION = "3.2.1"
+  VERSION = "3.3.3"
 end

data/spec/integration/dsl_spec.rb

@@ -36,10 +36,10 @@ describe Capistrano::DSL do
           end
         end
 
-        context 'with filter options' do
+        context 'with property filter options' do
           subject { dsl.release_roles(:all, filter: :active) }
 
-          it 'returns all release servers that match the filter' do
+          it 'returns all release servers that match the property filter' do
             expect(subject.map(&:hostname)).to eq %w{example1.com example3.com}
           end
         end
@@ -92,7 +92,7 @@ describe Capistrano::DSL do
           end
         end
 
-        context 'when the attribute `primary` is explicity set' do
+        context 'when the attribute `primary` is explicitly set' do
           subject { dsl.primary(:app) }
           it 'returns the servers' do
             expect(subject.hostname).to eq 'example4.com'
@@ -100,6 +100,38 @@ describe Capistrano::DSL do
         end
       end
 
+      describe 'setting an internal host filter' do
+        subject { dsl.roles(:app) }
+        it 'is ignored' do
+          dsl.set :filter, { host: 'example3.com' }
+          expect(subject.map(&:hostname)).to eq(['example3.com', 'example4.com'])
+        end
+      end
+
+      describe 'setting an internal role filter' do
+        subject { dsl.roles(:app) }
+        it 'ignores it' do
+          dsl.set :filter, { role: :web }
+          expect(subject.map(&:hostname)).to eq(['example3.com','example4.com'])
+        end
+      end
+
+      describe 'setting an internal host and role filter' do
+        subject { dsl.roles(:app) }
+        it 'ignores it' do
+          dsl.set :filter, { role: :web, host: 'example1.com' }
+          expect(subject.map(&:hostname)).to eq(['example3.com','example4.com'])
+        end
+      end
+
+      describe 'setting an internal regexp host filter' do
+        subject { dsl.roles(:all) }
+        it 'is ignored' do
+          dsl.set :filter, { host: /1/ }
+          expect(subject.map(&:hostname)).to eq(%w{example1.com example2.com example3.com example4.com example5.com})
+        end
+      end
+
     end
 
     describe 'when defining role with reserved name' do
@@ -218,11 +250,11 @@ describe Capistrano::DSL do
 
       describe 'fetching servers for a role' do
         it 'roles defined using the `server` syntax are included' do
-          expect(dsl.roles(:web)).to have(2).items
+          expect(dsl.roles(:web).size).to eq(2)
         end
 
         it 'roles defined using the `role` syntax are included' do
-          expect(dsl.roles(:app)).to have(2).items
+          expect(dsl.roles(:app).size).to eq(2)
         end
       end
 
@@ -317,22 +349,22 @@ describe Capistrano::DSL do
     context 'variable is an non-empty array' do
       let(:linked_files) { %w{1} }
 
-      it { should be_true }
+      it { expect(subject).to be_truthy }
     end
 
     context 'variable is an empty array' do
       let(:linked_files) { [] }
-      it { should be_false }
+      it { expect(subject).to be_falsey }
     end
 
     context 'variable exists, is not an array' do
       let(:linked_files) { stub }
-      it { should be_true }
+      it { expect(subject).to be_truthy }
     end
 
     context 'variable is nil' do
       let(:linked_files) { nil }
-      it { should be_false }
+      it { expect(subject).to be_falsey }
     end
   end
 
@@ -368,7 +400,7 @@ describe Capistrano::DSL do
     end
 
     it 'sets the backend pty' do
-      expect(backend.pty).to be_true
+      expect(backend.pty).to be_truthy
     end
 
     it 'sets the backend connection timeout' do
@@ -488,4 +520,91 @@ describe Capistrano::DSL do
       end
     end
   end
+
+  describe 'local_user' do
+    before do
+      dsl.set :local_user, -> { Etc.getlogin }
+    end
+
+    describe 'fetching local_user' do
+      subject { dsl.local_user }
+
+      context 'where a local_user is not set' do
+        before do
+          Etc.expects(:getlogin).returns('login')
+        end
+
+        it 'returns the login name' do
+          expect(subject.to_s).to eq 'login'
+        end
+      end
+
+      context 'where a local_user is set' do
+        before do
+          dsl.set(:local_user, -> { 'custom login' })
+        end
+
+        it 'returns the custom name' do
+          expect(subject.to_s).to eq 'custom login'
+        end
+      end
+    end
+  end
+
+  describe 'on()' do
+
+    before do
+      dsl.server 'example1.com', roles: %w{web}, active: true
+      dsl.server 'example2.com', roles: %w{web}
+      dsl.server 'example3.com', roles: %w{app web}, active: true
+      dsl.server 'example4.com', roles: %w{app}, primary: true
+      dsl.server 'example5.com', roles: %w{db}, no_release: true
+      @coordinator = mock('coordinator')
+      @coordinator.expects(:each).returns(nil)
+      ENV.delete 'ROLES'
+      ENV.delete 'HOSTS'
+
+    end
+
+    it 'filters by role from the :filter variable' do
+      hosts = dsl.roles(:web)
+      all = dsl.roles(:all)
+      SSHKit::Coordinator.expects(:new).with(hosts).returns(@coordinator)
+      dsl.set :filter, { role: 'web' }
+      dsl.on(all)
+    end
+
+    it 'filters by host and role from the :filter variable' do
+      all = dsl.roles(:all)
+      SSHKit::Coordinator.expects(:new).with([]).returns(@coordinator)
+      dsl.set :filter, { role: 'db', host: 'example3.com' }
+      dsl.on(all)
+    end
+
+    it 'filters from ENV[ROLES]' do
+      hosts = dsl.roles(:db)
+      all = dsl.roles(:all)
+      SSHKit::Coordinator.expects(:new).with(hosts).returns(@coordinator)
+      ENV['ROLES'] = 'db'
+      dsl.on(all)
+    end
+
+    it 'filters from ENV[HOSTS]' do
+      hosts = dsl.roles(:db)
+      all = dsl.roles(:all)
+      SSHKit::Coordinator.expects(:new).with(hosts).returns(@coordinator)
+      ENV['HOSTS'] = 'example5.com'
+      dsl.on(all)
+    end
+
+    it 'filters by ENV[HOSTS] && ENV[ROLES]' do
+      all = dsl.roles(:all)
+      SSHKit::Coordinator.expects(:new).with([]).returns(@coordinator)
+      ENV['HOSTS'] = 'example5.com'
+      ENV['ROLES'] = 'web'
+      dsl.on(all)
+    end
+
+  end
+
 end

data/spec/lib/capistrano/application_spec.rb

@@ -6,21 +6,39 @@ 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
+  let(:help_output) do
     out, _ = capture_io do
       flags '--help', '-h'
     end
-    out.lines.first.should match(/cap \[-f rakefile\]/)
+    out
+  end
+
+  it "displays documentation URL as help banner" do
+    expect(help_output.lines.first).to match(/capistranorb.com/)
+  end
+
+  %w(quiet silent verbose).each do |switch|
+    it "doesn't include --#{switch} in help" do
+      expect(help_output).not_to match(/--#{switch}/)
+    end
   end
 
   it "overrides the rake method, but still prints the rake version" do
     out, _ = capture_io do
       flags '--version', '-V'
     end
-    out.should match(/\bCapistrano Version\b/)
-    out.should match(/\b#{Capistrano::VERSION}\b/)
-    out.should match(/\bRake Version\b/)
-    out.should match(/\b#{RAKEVERSION}\b/)
+    expect(out).to match(/\bCapistrano Version\b/)
+    expect(out).to match(/\b#{Capistrano::VERSION}\b/)
+    expect(out).to match(/\bRake Version\b/)
+    expect(out).to match(/\b#{RAKEVERSION}\b/)
+  end
+
+  it "overrides the rake method, and sets the sshkit_backend to SSHKit::Backend::Printer" do
+    out, _ = capture_io do
+      flags '--dry-run', '-n'
+    end
+    sshkit_backend = Capistrano::Configuration.fetch(:sshkit_backend)
+    expect(sshkit_backend).to eq(SSHKit::Backend::Printer)
   end
 
   def flags(*sets)

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

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+module Capistrano
+  class Configuration
+
+    describe Filter do
+      let(:available) { [ Server.new('server1').add_roles([:web,:db]),
+                          Server.new('server2').add_role(:web),
+                          Server.new('server3').add_role(:redis),
+                          Server.new('server4').add_role(:db) ] }
+
+      describe '#new' do
+        it "won't create an invalid type of filter" do
+          expect {
+            f = Filter.new(:zarg)
+          }.to raise_error RuntimeError
+        end
+
+        it 'creates an empty host filter' do
+          expect(Filter.new(:host).filter(available)).to be_empty
+        end
+
+        it 'creates a null host filter' do
+          expect(Filter.new(:host, :all).filter(available)).to eq(available)
+        end
+
+        it 'creates an empty role filter' do
+          expect(Filter.new(:role).filter(available)).to be_empty
+        end
+
+        it 'creates a null role filter' do
+          expect(Filter.new(:role, :all).filter(available)).to eq(available)
+        end
+
+      end
+
+      describe 'host filter' do
+        it 'works with a single server' do
+          set = Filter.new(:host, 'server1').filter(available.first)
+          expect(set.map(&:hostname)).to eq(%w{server1})
+        end
+        it 'returns all hosts matching a string' do
+          set = Filter.new(:host, 'server1').filter(available)
+          expect(set.map(&:hostname)).to eq(%w{server1})
+        end
+        it 'returns all hosts matching a comma-separated string' do
+          set = Filter.new(:host, 'server1,server3').filter(available)
+          expect(set.map(&:hostname)).to eq(%w{server1 server3})
+        end
+        it 'returns all hosts matching an array of strings' do
+          set = Filter.new(:host, %w{server1 server3}).filter(available)
+          expect(set.map(&:hostname)).to eq(%w{server1 server3})
+        end
+        it 'returns all hosts matching regexp' do
+          set = Filter.new(:host, 'server[13]$').filter(available)
+          expect(set.map(&:hostname)).to eq(%w{server1 server3})
+        end
+        it 'correctly identifies a regex with a comma in' do
+          set = Filter.new(:host, 'server\d{1,3}$').filter(available)
+          expect(set.map(&:hostname)).to eq(%w{server1 server2 server3 server4})
+        end
+      end
+
+      describe 'role filter' do
+        it 'returns all hosts' do
+          set = Filter.new(:role, [:all]).filter(available)
+          expect(set.size).to eq(available.size)
+          expect(set.first.hostname).to eq('server1')
+        end
+        it 'returns hosts in a single string role' do
+          set = Filter.new(:role, 'web').filter(available)
+          expect(set.size).to eq(2)
+          expect(set.map(&:hostname)).to eq(%w{server1 server2})
+        end
+        it 'returns hosts in a single role' do
+          set = Filter.new(:role, [:web]).filter(available)
+          expect(set.size).to eq(2)
+          expect(set.map(&:hostname)).to eq(%w{server1 server2})
+        end
+        it 'returns hosts in multiple roles specified by a string' do
+          set = Filter.new(:role, 'web,db').filter(available)
+          expect(set.size).to eq(3)
+          expect(set.map(&:hostname)).to eq(%w{server1 server2 server4})
+        end
+        it 'returns hosts in multiple roles' do
+          set = Filter.new(:role, [:web, :db]).filter(available)
+          expect(set.size).to eq(3)
+          expect(set.map(&:hostname)).to eq(%w{server1 server2 server4})
+        end
+        it 'returns hosts with regex role selection' do
+          set = Filter.new(:role, /red/).filter(available)
+          expect(set.map(&:hostname)).to eq(%w{server3})
+        end
+        it 'returns hosts with regex role selection using a string' do
+          set = Filter.new(:role, '/red|web/').filter(available)
+          expect(set.map(&:hostname)).to eq(%w{server1 server2 server3})
+        end
+        it 'returns hosts with combination of string role and regex' do
+          set = Filter.new(:role, 'db,/red/').filter(available)
+          expect(set.map(&:hostname)).to eq(%w{server1 server3 server4})
+        end
+      end
+    end
+  end
+end

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

@@ -5,31 +5,38 @@ module Capistrano
 
     describe Question do
 
-      let(:question) { Question.new(env, key, default) }
+      let(:question) { Question.new(key, default, options) }
+      let(:question_without_echo) { Question.new(key, default, echo: false) }
       let(:default) { :default }
       let(:key) { :branch }
-      let(:env) { stub }
+      let(:options) { nil }
 
       describe '.new' do
-        it 'takes a key, default' do
+        it 'takes a key, default, options' do
           question
         end
       end
 
       describe '#call' do
-        subject { question.call }
-
         context 'value is entered' do
           let(:branch) { 'branch' }
 
           before do
             $stdout.expects(:print).with('Please enter branch (default): ')
+          end
+
+          it 'returns the echoed value' do
             $stdin.expects(:gets).returns(branch)
+            $stdin.expects(:noecho).never
+
+            expect(question.call).to eq(branch)
           end
 
-          it 'sets the value' do
-            env.expects(:set).with(key, branch)
-            question.call
+          it 'returns the value but does not echo it' do
+            $stdin.expects(:noecho).returns(branch)
+            $stdout.expects(:print).with("\n")
+
+            expect(question_without_echo.call).to eq(branch)
           end
         end
 
@@ -41,11 +48,10 @@ module Capistrano
             $stdin.expects(:gets).returns('')
           end
 
-          it 'sets the default as the value' do
-            env.expects(:set).with(key, branch)
-            question.call
-          end
 
+          it 'returns the default as the value' do
+            expect(question.call).to eq(branch)
+          end
         end
       end
     end

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

@@ -28,7 +28,7 @@ module Capistrano
         end
 
         it 'adds the role' do
-          expect{subject}.to be_true
+          expect(subject).to be_truthy
         end
       end
 
@@ -37,22 +37,22 @@ module Capistrano
 
         context 'with the same user, hostname and port' do
           let(:hostname) { 'root@hostname:1234' }
-          it { should be_true }
+          it { expect(subject).to be_truthy }
         end
 
         context 'with a different user' do
           let(:hostname) { 'deployer@hostname:1234' }
-          it { should be_false }
+          it { expect(subject).to be_falsey }
         end
 
         context 'with a different port' do
           let(:hostname) { 'root@hostname:5678' }
-          it { should be_false }
+          it { expect(subject).to be_falsey }
         end
 
         context 'with a different hostname' do
           let(:hostname) { 'root@otherserver:1234' }
-          it { should be_false }
+          it { expect(subject).to be_falsey }
         end
       end
 
@@ -69,7 +69,7 @@ module Capistrano
 
         context 'server is not primary' do
           it 'is falesy' do
-            expect(subject).to be_false
+            expect(subject).to be_falsey
           end
         end
       end
@@ -149,7 +149,7 @@ module Capistrano
         end
 
         context 'options are empty' do
-          it { should be_true }
+          it { expect(subject).to be_truthy }
         end
 
         context 'value is a symbol' do
@@ -157,34 +157,34 @@ module Capistrano
 
             context 'with :filter' do
               let(:options) { { filter: :active }}
-              it { should be_true }
+              it { expect(subject).to be_truthy }
             end
 
             context 'with :select' do
               let(:options) { { select: :active }}
-              it { should be_true }
+              it { expect(subject).to be_truthy }
             end
 
             context 'with :exclude' do
               let(:options) { { exclude: :active }}
-              it { should be_false }
+              it { expect(subject).to be_falsey }
             end
           end
 
           context 'value does not match server properly' do
             context 'with :filter' do
               let(:options) { { filter: :inactive }}
-              it { should be_false }
+              it { expect(subject).to be_falsey }
             end
 
             context 'with :select' do
               let(:options) { { select: :inactive }}
-              it { should be_false }
+              it { expect(subject).to be_falsey }
             end
 
             context 'with :exclude' do
               let(:options) { { exclude: :inactive }}
-              it { should be_true }
+              it { expect(subject).to be_truthy }
             end
           end
         end
@@ -194,17 +194,17 @@ module Capistrano
 
             context 'with :filter' do
               let(:options) { { filter: ->(s) { s.properties.active } } }
-              it { should be_true }
+              it { expect(subject).to be_truthy }
             end
 
             context 'with :select' do
               let(:options) { { select: ->(s) { s.properties.active } } }
-              it { should be_true }
+              it { expect(subject).to be_truthy }
             end
 
             context 'with :exclude' do
               let(:options) { { exclude: ->(s) { s.properties.active } } }
-              it { should be_false }
+              it { expect(subject).to be_falsey }
             end
 
           end
@@ -212,17 +212,17 @@ module Capistrano
           context 'value does not match server properly' do
             context 'with :filter' do
               let(:options) { { filter: ->(s) { s.properties.inactive } } }
-              it { should be_false }
+              it { expect(subject).to be_falsey }
             end
 
             context 'with :select' do
               let(:options) { { select: ->(s) { s.properties.inactive } } }
-              it { should be_false }
+              it { expect(subject).to be_falsey }
             end
 
             context 'with :exclude' do
               let(:options) { { exclude: ->(s) { s.properties.inactive } } }
-              it { should be_true }
+              it { expect(subject).to be_truthy }
             end
 
           end