capistrano 3.4.0 → 3.17.1

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,46 +1,46 @@
-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'
-    end
-    out
-  end
-
-  it "displays documentation URL as help banner" do
-    expect(help_output.lines.first).to match(/capistranorb.com/)
+  it "displays documentation URL as help banner", capture_io: true do
+    flags "--help", "-h"
+    expect($stdout.string.each_line.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}/)
+    it "doesn't include --#{switch} in help", capture_io: true do
+      flags "--help", "-h"
+      expect($stdout.string).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
+  it "overrides the rake method, but still prints the rake version", capture_io: true do
+    flags "--version", "-V"
+    out = $stdout.string
     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/)
+    expect(out).to match(/\b#{Rake::VERSION}\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
+  it "overrides the rake method, and sets the sshkit_backend to SSHKit::Backend::Printer", capture_io: true do
+    flags "--dry-run", "-n"
     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", capture_io: true do
+    begin
+      flags "--print-config-variables", "-p"
+      expect(Capistrano::Configuration.fetch(:print_config_variables)).to be true
+    ensure
+      Capistrano::Configuration.reset!
+    end
+  end
+
   def flags(*sets)
     sets.each do |set|
       ARGV.clear
@@ -51,26 +51,10 @@ 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
     subject.options
   end
-
-  def capture_io
-    require 'stringio'
-
-    orig_stdout, orig_stderr         = $stdout, $stderr
-    captured_stdout, captured_stderr = StringIO.new, StringIO.new
-    $stdout, $stderr                 = captured_stdout, captured_stderr
-
-    yield
-
-    return captured_stdout.string, captured_stderr.string
-  ensure
-    $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(%i(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
+      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,71 @@
+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("server10")]
+      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,server10" }
+          it_behaves_like "it filters hosts correctly", %w{server1 server10}
+        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 mixed splittable and unsplittable strings" do
+          let(:values) { %w{server1 server2,server3} }
+          it_behaves_like "it filters hosts correctly", %w{server1 server2 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 server10}
+        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 server10}
+        end
+
+        context "without number" do
+          let(:values) { "server" }
+          it_behaves_like "it filters hosts correctly", %w{}
+        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/plugin_installer_spec.rb

@@ -0,0 +1,98 @@
+require "spec_helper"
+require "capistrano/plugin"
+require "capistrano/scm/plugin"
+
+module Capistrano
+  class Configuration
+    class ExamplePlugin < Capistrano::Plugin
+      def set_defaults
+        set_if_empty :example_variable, "foo"
+      end
+
+      def define_tasks
+        task :example
+        task :example_prerequisite
+      end
+
+      def register_hooks
+        before :example, :example_prerequisite
+      end
+    end
+
+    class ExampleSCMPlugin < Capistrano::SCM::Plugin
+    end
+
+    describe PluginInstaller do
+      include Capistrano::DSL
+
+      let(:installer) { PluginInstaller.new }
+      let(:options) { {} }
+      let(:plugin) { ExamplePlugin.new }
+
+      before do
+        installer.install(plugin, **options)
+      end
+
+      after do
+        Rake::Task.clear
+        Capistrano::Configuration.reset!
+      end
+
+      context "installing plugin" do
+        it "defines tasks" do
+          expect(Rake::Task[:example]).to_not be_nil
+          expect(Rake::Task[:example_prerequisite]).to_not be_nil
+        end
+
+        it "registers hooks" do
+          task = Rake::Task[:example]
+          expect(task.prerequisites).to eq([:example_prerequisite])
+        end
+
+        it "sets defaults when load:defaults is invoked", capture_io: true do
+          expect(fetch(:example_variable)).to be_nil
+          invoke "load:defaults"
+          expect(fetch(:example_variable)).to eq("foo")
+        end
+
+        it "doesn't say an SCM is installed" do
+          expect(installer.scm_installed?).to be_falsey
+        end
+      end
+
+      context "installing plugin class" do
+        let(:plugin) { ExamplePlugin }
+
+        it "defines tasks" do
+          expect(Rake::Task[:example]).to_not be_nil
+          expect(Rake::Task[:example_prerequisite]).to_not be_nil
+        end
+      end
+
+      context "installing plugin without hooks" do
+        let(:options) { { load_hooks: false } }
+
+        it "doesn't register hooks" do
+          task = Rake::Task[:example]
+          expect(task.prerequisites).to be_empty
+        end
+      end
+
+      context "installing plugin and loading immediately" do
+        let(:options) { { load_immediately: true } }
+
+        it "sets defaults immediately" do
+          expect(fetch(:example_variable)).to eq("foo")
+        end
+      end
+
+      context "installing an SCM plugin" do
+        let(:plugin) { ExampleSCMPlugin }
+
+        it "says an SCM is installed" do
+          expect(installer.scm_installed?).to be_truthy
+        end
+      end
+    end
+  end
+end

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

@@ -1,60 +1,92 @@
-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(:question) { Question.new(key, default, stdin: stdin) }
+      let(:question_without_echo) { Question.new(key, default, echo: false, stdin: stdin) }
+      let(:question_without_default) { Question.new(key, nil, stdin: stdin) }
+      let(:question_prompt) { Question.new(key, default, stdin: stdin, prompt: "Your favorite branch") }
+      let(:question_prompt_without_default) { Question.new(key, nil, stdin: stdin, prompt: "Your favorite branch") }
       let(:default) { :default }
       let(:key) { :branch }
-      let(:options) { nil }
+      let(:stdin) { stub(tty?: true) }
 
-      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' }
-
-          before do
-            $stdout.expects(:print).with('Please enter branch (default): ')
-          end
+      describe "#call" do
+        context "value is entered" do
+          let(:branch) { "branch" }
 
-          it 'returns the echoed value' do
-            $stdin.expects(:gets).returns(branch)
-            $stdin.expects(:noecho).never
+          it "returns the echoed value" do
+            $stdout.expects(:print).with("Please enter branch (default): ")
+            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
-            $stdin.expects(:noecho).returns(branch)
+          it "returns the value but does not echo it" do
+            $stdout.expects(:print).with("Please enter branch (default): ")
+            stdin.expects(:noecho).returns(branch)
             $stdout.expects(:print).with("\n")
 
             expect(question_without_echo.call).to eq(branch)
           end
+
+          it "returns the value but has no default between parenthesis" do
+            $stdout.expects(:print).with("Please enter branch: ")
+            stdin.expects(:gets).returns(branch)
+            stdin.expects(:noecho).never
+
+            expect(question_without_default.call).to eq(branch)
+          end
+
+          it "uses prompt and returns the value" do
+            $stdout.expects(:print).with("Your favorite branch (default): ")
+            stdin.expects(:gets).returns(branch)
+            stdin.expects(:noecho).never
+
+            expect(question_prompt.call).to eq(branch)
+          end
+
+          it "uses prompt and returns the value but has no default between parenthesis" do
+            $stdout.expects(:print).with("Your favorite branch: ")
+            stdin.expects(:gets).returns(branch)
+            stdin.expects(:noecho).never
+
+            expect(question_prompt_without_default.call).to eq(branch)
+          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
+
+        context "tty unavailable", capture_io: true do
+          before do
+            stdin.expects(:gets).never
+            stdin.expects(:tty?).returns(false)
+          end
+
+          it "returns the default as the value" do
+            expect(question.call).to eq(default)
+          end
+        end
       end
     end
-
   end
 end