capistrano 3.4.1 → 3.5.0

data/spec/integration_spec_helper.rb

@@ -1,7 +1,5 @@
-require 'spec_helper'
-require 'support/test_app'
-require 'support/matchers'
+require "spec_helper"
+require "support/test_app"
+require "support/matchers"
 
 include TestApp
-
-

data/spec/lib/capistrano/application_spec.rb

@@ -1,14 +1,13 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Capistrano::Application do
-
   it "provides a --trace option which enables SSHKit/NetSSH trace output"
 
   it "provides a --format option which enables the choice of output formatting"
 
   let(:help_output) do
-    out, _ = capture_io do
-      flags '--help', '-h'
+    out, _err = capture_io do
+      flags "--help", "-h"
     end
     out
   end
@@ -24,8 +23,8 @@ describe Capistrano::Application do
   end
 
   it "overrides the rake method, but still prints the rake version" do
-    out, _ = capture_io do
-      flags '--version', '-V'
+    out, _err = capture_io do
+      flags "--version", "-V"
     end
     expect(out).to match(/\bCapistrano Version\b/)
     expect(out).to match(/\b#{Capistrano::VERSION}\b/)
@@ -34,13 +33,20 @@ describe Capistrano::Application do
   end
 
   it "overrides the rake method, and sets the sshkit_backend to SSHKit::Backend::Printer" do
-    out, _ = capture_io do
-      flags '--dry-run', '-n'
+    capture_io do
+      flags "--dry-run", "-n"
     end
     sshkit_backend = Capistrano::Configuration.fetch(:sshkit_backend)
     expect(sshkit_backend).to eq(SSHKit::Backend::Printer)
   end
 
+  it "enables printing all config variables on command line parameter" do
+    capture_io do
+      flags "--print-config-variables", "-p"
+    end
+    expect(Capistrano::Configuration.fetch(:print_config_variables)).to be true
+  end
+
   def flags(*sets)
     sets.each do |set|
       ARGV.clear
@@ -51,7 +57,7 @@ describe Capistrano::Application do
 
   def command_line(*options)
     options.each { |opt| ARGV << opt }
-    def subject.exit(*args)
+    subject.define_singleton_method(:exit) do |*_args|
       throw(:system_exit, :exit)
     end
     subject.run
@@ -59,11 +65,14 @@ describe Capistrano::Application do
   end
 
   def capture_io
-    require 'stringio'
+    require "stringio"
 
-    orig_stdout, orig_stderr         = $stdout, $stderr
-    captured_stdout, captured_stderr = StringIO.new, StringIO.new
-    $stdout, $stderr                 = captured_stdout, captured_stderr
+    orig_stdout = $stdout
+    orig_stderr = $stderr
+    captured_stdout = StringIO.new
+    captured_stderr = StringIO.new
+    $stdout = captured_stdout
+    $stderr = captured_stderr
 
     yield
 
@@ -72,5 +81,4 @@ describe Capistrano::Application do
     $stdout = orig_stdout
     $stderr = orig_stderr
   end
-
 end

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

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+module Capistrano
+  class Configuration
+    describe EmptyFilter do
+      subject(:empty_filter) { EmptyFilter.new }
+
+      describe '#filter' do
+        let(:servers) { mock("servers") }
+
+        it "returns an empty array" do
+          expect(empty_filter.filter(servers)).to eq([])
+        end
+      end
+    end
+  end
+end

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

@@ -1,109 +1,107 @@
-require 'spec_helper'
+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),
-                          Server.new('server5').add_role(:stageweb) ] }
+      let(:available) do
+        [
+          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),
+          Server.new("server5").add_role(:stageweb)
+        ]
+      end
 
       describe '#new' do
         it "won't create an invalid type of filter" do
-          expect {
-            f = Filter.new(:zarg)
-          }.to raise_error RuntimeError
+          expect do
+            Filter.new(:zarg)
+          end.to raise_error RuntimeError
         end
 
-        it 'creates an empty host filter' do
-          expect(Filter.new(:host).filter(available)).to be_empty
-        end
+        context "with type :host" do
+          context "and no values" do
+            it "creates an EmptyFilter strategy" do
+              expect(Filter.new(:host).instance_variable_get(:@strategy)).to be_a(EmptyFilter)
+            end
+          end
 
-        it 'creates a null host filter' do
-          expect(Filter.new(:host, :all).filter(available)).to eq(available)
-        end
+          context "and :all" do
+            it "creates an NullFilter strategy" do
+              expect(Filter.new(:host, :all).instance_variable_get(:@strategy)).to be_a(NullFilter)
+            end
+          end
 
-        it 'creates an empty role filter' do
-          expect(Filter.new(:role).filter(available)).to be_empty
-        end
+          context "and [:all]" do
+            it "creates an NullFilter strategy" do
+              expect(Filter.new(:host, [:all]).instance_variable_get(:@strategy)).to be_a(NullFilter)
+            end
+          end
 
-        it 'creates a null role filter' do
-          expect(Filter.new(:role, :all).filter(available)).to eq(available)
+          context "and [:all]" do
+            it "creates an NullFilter strategy" do
+              expect(Filter.new(:host, "all").instance_variable_get(:@strategy)).to be_a(NullFilter)
+            end
+          end
         end
 
-      end
+        context "with type :role" do
+          context "and no values" do
+            it "creates an EmptyFilter strategy" do
+              expect(Filter.new(:role).instance_variable_get(:@strategy)).to be_a(EmptyFilter)
+            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 server5})
+          context "and :all" do
+            it "creates an NullFilter strategy" do
+              expect(Filter.new(:role, :all).instance_variable_get(:@strategy)).to be_a(NullFilter)
+            end
+          end
+
+          context "and [:all]" do
+            it "creates an NullFilter strategy" do
+              expect(Filter.new(:role, [:all]).instance_variable_get(:@strategy)).to be_a(NullFilter)
+            end
+          end
+
+          context "and [:all]" do
+            it "creates an NullFilter strategy" do
+              expect(Filter.new(:role, "all").instance_variable_get(:@strategy)).to be_a(NullFilter)
+            end
+          end
         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})
+      describe '#filter' do
+        let(:strategy) { filter.instance_variable_get(:@strategy) }
+        let(:results) { mock("result") }
+
+        shared_examples 'it calls #filter on its strategy' do
+          it 'calls #filter on its strategy' do
+            strategy.expects(:filter).with(available).returns(results)
+            expect(filter.filter(available)).to eq(results)
+          end
         end
-        it 'returns only hosts for explicit roles' do
-          set = Filter.new(:role, [:web]).filter(available)
-          expect(set.size).to eq(2)
-          expect(set.map(&:hostname)).to eq(%w{server1 server2})
+
+        context "for an empty filter" do
+          let(:filter) { Filter.new(:role) }
+          it_behaves_like 'it calls #filter on its strategy'
         end
-        it 'returns hosts with regex role selection' do
-          set = Filter.new(:role, /red/).filter(available)
-          expect(set.map(&:hostname)).to eq(%w{server3})
+
+        context "for a null filter" do
+          let(:filter) { Filter.new(:role, :all) }
+          it_behaves_like 'it calls #filter on its strategy'
         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 server5})
+
+        context "for a role filter" do
+          let(:filter) { Filter.new(:role, "web") }
+          it_behaves_like 'it calls #filter on its strategy'
         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})
+
+        context "for a host filter" do
+          let(:filter) { Filter.new(:host, "server1") }
+          it_behaves_like 'it calls #filter on its strategy'
         end
       end
     end

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

@@ -0,0 +1,61 @@
+require "spec_helper"
+
+module Capistrano
+  class Configuration
+    describe HostFilter do
+      subject(:host_filter) { HostFilter.new(values) }
+
+      let(:available) do
+        [Server.new("server1"),
+         Server.new("server2"),
+         Server.new("server3"),
+         Server.new("server4"),
+         Server.new("server5")]
+      end
+
+      shared_examples "it filters hosts correctly" do |expected|
+        it "filters correctly" do
+          set = host_filter.filter(available)
+          expect(set.map(&:hostname)).to eq(expected)
+        end
+      end
+
+      describe '#filter' do
+        context "with a string" do
+          let(:values) { "server1" }
+          it_behaves_like "it filters hosts correctly", %w{server1}
+
+          context "and a single server" do
+            let(:available) { Server.new("server1") }
+            it_behaves_like "it filters hosts correctly", %w{server1}
+          end
+        end
+
+        context "with a comma separated string" do
+          let(:values) { "server1,server3" }
+          it_behaves_like "it filters hosts correctly", %w{server1 server3}
+        end
+
+        context "with an array of strings" do
+          let(:values) { %w{server1 server3} }
+          it_behaves_like "it filters hosts correctly", %w{server1 server3}
+        end
+
+        context "with a regexp" do
+          let(:values) { "server[13]$" }
+          it_behaves_like "it filters hosts correctly", %w{server1 server3}
+        end
+
+        context "with a regexp with line boundaries" do
+          let(:values) { "^server" }
+          it_behaves_like "it filters hosts correctly", %w{server1 server2 server3 server4 server5}
+        end
+
+        context "with a regexp with a comma" do
+          let(:values) { 'server\d{1,3}$' }
+          it_behaves_like "it filters hosts correctly", %w{server1 server2 server3 server4 server5}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+module Capistrano
+  class Configuration
+    describe NullFilter do
+      subject(:null_filter) { NullFilter.new }
+
+      describe '#filter' do
+        let(:servers) { mock("servers") }
+
+        it "returns the servers passed in as arguments" do
+          expect(null_filter.filter(servers)).to eq(servers)
+        end
+      end
+    end
+  end
+end

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

@@ -1,38 +1,36 @@
-require 'spec_helper'
+require "spec_helper"
 
 module Capistrano
   class Configuration
-
     describe Question do
-
       let(:question) { Question.new(key, default, options) }
       let(:question_without_echo) { Question.new(key, default, echo: false) }
       let(:default) { :default }
       let(:key) { :branch }
       let(:options) { nil }
 
-      describe '.new' do
-        it 'takes a key, default, options' do
+      describe ".new" do
+        it "takes a key, default, options" do
           question
         end
       end
 
       describe '#call' do
-        context 'value is entered' do
-          let(:branch) { 'branch' }
+        context "value is entered" do
+          let(:branch) { "branch" }
 
           before do
-            $stdout.expects(:print).with('Please enter branch (default): ')
+            $stdout.expects(:print).with("Please enter branch (default): ")
           end
 
-          it 'returns the echoed value' do
+          it "returns the echoed value" do
             $stdin.expects(:gets).returns(branch)
             $stdin.expects(:noecho).never
 
             expect(question.call).to eq(branch)
           end
 
-          it 'returns the value but does not echo it' do
+          it "returns the value but does not echo it" do
             $stdin.expects(:noecho).returns(branch)
             $stdout.expects(:print).with("\n")
 
@@ -40,21 +38,19 @@ module Capistrano
           end
         end
 
-        context 'value is not entered' do
+        context "value is not entered" do
           let(:branch) { default }
 
           before do
-            $stdout.expects(:print).with('Please enter branch (default): ')
-            $stdin.expects(:gets).returns('')
+            $stdout.expects(:print).with("Please enter branch (default): ")
+            $stdin.expects(:gets).returns("")
           end
 
-
-          it 'returns the default as the value' do
+          it "returns the default as the value" do
             expect(question.call).to eq(branch)
           end
         end
       end
     end
-
   end
 end