capistrano 3.4.0 → 3.17.1

data/spec/lib/capistrano/configuration_spec.rb

@@ -1,34 +1,34 @@
-require 'spec_helper'
+require "spec_helper"
 
 module Capistrano
   describe Configuration do
     let(:config) { Configuration.new }
     let(:servers) { stub }
 
-    describe '.new' do
-      it 'accepts initial hash' do
-        configuration = described_class.new(custom: 'value')
-        expect(configuration.fetch(:custom)).to eq('value')
+    describe ".new" do
+      it "accepts initial hash" do
+        configuration = described_class.new(custom: "value")
+        expect(configuration.fetch(:custom)).to eq("value")
       end
     end
 
-    describe '.env' do
-      it 'is a global accessor to a single instance' do
+    describe ".env" do
+      it "is a global accessor to a single instance" do
         Configuration.env.set(:test, true)
         expect(Configuration.env.fetch(:test)).to be_truthy
       end
     end
 
-    describe '.reset!' do
-      it 'blows away the existing `env` and creates a new one' do
+    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
+    describe "roles" do
+      context "adding a role" do
         subject { config.role(:app, %w{server1 server2}) }
 
         before do
@@ -36,103 +36,200 @@ module Capistrano
           servers.expects(:add_role).with(:app, %w{server1 server2}, {})
         end
 
-        it 'adds the role' do
+        it "adds the role" do
           expect(subject)
         end
       end
     end
 
-    describe 'setting and fetching' do
+    describe "setting and fetching" do
       subject { config.fetch(:key, :default) }
 
-      context 'value is set' do
-        before do
+      context "set" do
+        it "sets by value" do
           config.set(:key, :value)
+          expect(subject).to eq :value
         end
 
-        it 'returns the set value' do
+        it "sets by block" do
+          config.set(:key) { :value }
           expect(subject).to eq :value
         end
+
+        it "raises an exception when given both a value and block" do
+          expect { config.set(:key, :value) { :value } }.to raise_error(Capistrano::ValidationError)
+        end
       end
 
-      context 'set_if_empty' do
-        it 'sets the value when none is present' do
+      context "set_if_empty" do
+        it "sets by value when none is present" do
           config.set_if_empty(:key, :value)
           expect(subject).to eq :value
         end
 
-        it 'does not overwrite the value' do
+        it "sets by block when none is present" do
+          config.set_if_empty(:key) { :value }
+          expect(subject).to eq :value
+        end
+
+        it "does not overwrite existing values" do
           config.set(:key, :value)
           config.set_if_empty(:key, :update)
+          config.set_if_empty(:key) { :update }
           expect(subject).to eq :value
         end
       end
 
-      context 'value is not set' do
-        it 'returns the default value' do
+      context "value is not set" do
+        it "returns the default value" do
           expect(subject).to eq :default
         end
       end
 
-      context 'value is a proc' do
-        subject { config.fetch(:key, Proc.new { :proc } ) }
-        it 'calls the proc' do
+      context "value is a proc" do
+        subject { config.fetch(:key, proc { :proc }) }
+        it "calls the proc" do
           expect(subject).to eq :proc
         end
       end
 
-      context 'value is a lambda' do
-        subject { config.fetch(:key, lambda { :lambda } ) }
-        it 'calls the lambda' do
+      context "value is a lambda" do
+        subject { config.fetch(:key, -> { :lambda }) }
+        it "calls the lambda" do
           expect(subject).to eq :lambda
         end
       end
 
-      context 'value inside proc inside a proc' do
-        subject { config.fetch(:key, Proc.new { Proc.new { "some value" } } ) }
-        it 'calls all procs and lambdas' do
+      context "value inside proc inside a proc" do
+        subject { config.fetch(:key, proc { proc { "some value" } }) }
+        it "calls all procs and lambdas" do
           expect(subject).to eq "some value"
         end
       end
 
-      context 'value inside lambda inside a lambda' do
-        subject { config.fetch(:key, lambda { lambda { "some value" } } ) }
-        it 'calls all procs and lambdas' do
+      context "value inside lambda inside a lambda" do
+        subject { config.fetch(:key, -> { -> { "some value" } }) }
+        it "calls all procs and lambdas" do
           expect(subject).to eq "some value"
         end
       end
 
-      context 'value inside lambda inside a proc' do
-        subject { config.fetch(:key, Proc.new { lambda { "some value" } } ) }
-        it 'calls all procs and lambdas' do
+      context "value inside lambda inside a proc" do
+        subject { config.fetch(:key, proc { -> { "some value" } }) }
+        it "calls all procs and lambdas" do
           expect(subject).to eq "some value"
         end
       end
 
-      context 'value inside proc inside a lambda' do
-        subject { config.fetch(:key, lambda { Proc.new { "some value" } } ) }
-        it 'calls all procs and lambdas' do
+      context "value inside proc inside a lambda" do
+        subject { config.fetch(:key, -> { proc { "some value" } }) }
+        it "calls all procs and lambdas" do
           expect(subject).to eq "some value"
         end
       end
 
-      context 'lambda with parameters' do
-        subject { config.fetch(:key, lambda { |c| c }).call(42) }
-        it 'is returned as a lambda' do
+      context "lambda with parameters" do
+        subject { config.fetch(:key, ->(c) { c }).call(42) }
+        it "is returned as a lambda" do
           expect(subject).to eq 42
         end
       end
 
-      context 'block is passed to fetch' do
-        subject { config.fetch(:key, :default) { fail 'we need this!' } }
+      context "block is passed to fetch" do
+        subject { config.fetch(:key, :default) { raise "we need this!" } }
+
+        it "returns the block value" do
+          expect { subject }.to raise_error(RuntimeError)
+        end
+      end
+
+      context "validations" do
+        before do
+          config.validate :key do |_, value|
+            raise Capistrano::ValidationError unless value.length > 3
+          end
+        end
+
+        it "validates string without error" do
+          config.set(:key, "longer_value")
+        end
+
+        it "validates block without error" do
+          config.set(:key) { "longer_value" }
+          expect(config.fetch(:key)).to eq "longer_value"
+        end
+
+        it "validates lambda without error" do
+          config.set :key, -> { "longer_value" }
+          expect(config.fetch(:key)).to eq "longer_value"
+        end
+
+        it "raises an exception on invalid string" do
+          expect { config.set(:key, "sho") }.to raise_error(Capistrano::ValidationError)
+        end
+
+        it "raises an exception on invalid string provided by block" do
+          config.set(:key) { "sho" }
+          expect { config.fetch(:key) }.to raise_error(Capistrano::ValidationError)
+        end
+
+        it "raises an exception on invalid string provided by lambda" do
+          config.set :key, -> { "sho" }
+          expect { config.fetch(:key) }.to raise_error(Capistrano::ValidationError)
+        end
+      end
+
+      context "appending" do
+        subject { config.append(:linked_dirs, "vendor/bundle", "tmp") }
+
+        it "returns appended value" do
+          expect(subject).to eq ["vendor/bundle", "tmp"]
+        end
+
+        context "on non-array variable" do
+          before { config.set(:linked_dirs, "string") }
+          subject { config.append(:linked_dirs, "vendor/bundle") }
+
+          it "returns appended value" do
+            expect(subject).to eq ["string", "vendor/bundle"]
+          end
+        end
+      end
+
+      context "removing" do
+        before :each do
+          config.set(:linked_dirs, ["vendor/bundle", "tmp"])
+        end
+
+        subject { config.remove(:linked_dirs, "vendor/bundle") }
 
-        it 'returns the block value' do
-          expect { subject }.to raise_error
+        it "returns without removed value" do
+          expect(subject).to eq ["tmp"]
+        end
+
+        context "on non-array variable" do
+          before { config.set(:linked_dirs, "string") }
+
+          context "when removing same value" do
+            subject { config.remove(:linked_dirs, "string") }
+
+            it "returns without removed value" do
+              expect(subject).to eq []
+            end
+          end
+
+          context "when removing different value" do
+            subject { config.remove(:linked_dirs, "othervalue") }
+
+            it "returns without removed value" do
+              expect(subject).to eq ["string"]
+            end
+          end
         end
       end
     end
 
-    describe 'keys' do
+    describe "keys" do
       subject { config.keys }
 
       before do
@@ -140,56 +237,120 @@ module Capistrano
         config.set(:key2, :value2)
       end
 
-      it 'returns all set keys' do
-        expect(subject).to match_array [:key1, :key2]
+      it "returns all set keys" do
+        expect(subject).to match_array %i(key1 key2)
       end
     end
 
-    describe 'deleting' do
+    describe "deleting" do
       before do
         config.set(:key, :value)
       end
 
-      it 'deletes the value' do
+      it "deletes the value" do
         config.delete(:key)
         expect(config.fetch(:key)).to be_nil
       end
     end
 
-    describe 'asking' do
+    describe "asking" do
       let(:question) { stub }
-      let(:options) { Hash.new }
+      let(:options) { {} }
 
       before do
-        Configuration::Question.expects(:new).with(:branch, :default, options).
-          returns(question)
+        Configuration::Question.expects(:new).with(:branch, :default, options)
+                               .returns(question)
       end
 
-      it 'prompts for the value when fetching' do
+      it "prompts for the value when fetching" do
         config.ask(:branch, :default, options)
         expect(config.fetch(:branch)).to eq question
       end
     end
 
-    describe 'setting the backend' do
-      it 'by default, is SSHKit' do
+    describe "setting the backend" do
+      it "by default, is SSHKit" do
         expect(config.backend).to eq SSHKit
       end
 
-      it 'can be set to another class' do
+      it "can be set to another class" do
         config.backend = :test
         expect(config.backend).to eq :test
       end
 
       describe "ssh_options for Netssh" do
-        it 'merges them with the :ssh_options variable' do
+        it "merges them with the :ssh_options variable" do
           config.set :format, :pretty
           config.set :log_level, :debug
-          config.set :ssh_options, { user: 'albert' }
-          SSHKit::Backend::Netssh.configure do |ssh| ssh.ssh_options = { password: 'einstein' } end
+          config.set :ssh_options, user: "albert"
+          SSHKit::Backend::Netssh.configure { |ssh| ssh.ssh_options = { password: "einstein" } }
           config.configure_backend
-          expect(config.backend.config.backend.config.ssh_options).to eq({ user: 'albert', password: 'einstein' })
+
+          expect(
+            config.backend.config.backend.config.ssh_options
+          ).to include(user: "albert", password: "einstein")
+        end
+      end
+    end
+
+    describe "dry_run?" do
+      it "returns false when using default backend" do
+        expect(config.dry_run?).to eq(false)
+      end
+
+      it "returns true when using printer backend" do
+        config.set :sshkit_backend, SSHKit::Backend::Printer
+
+        expect(config.dry_run?).to eq(true)
+      end
+    end
+
+    describe "custom filtering" do
+      it "accepts a custom filter object" do
+        filter = Object.new
+        def filter.filter(servers)
+          servers
         end
+        config.add_filter(filter)
+      end
+
+      it "accepts a custom filter as a block" do
+        config.add_filter { |servers| servers }
+      end
+
+      it "raises an error if passed a block and an object" do
+        filter = Object.new
+        def filter.filter(servers)
+          servers
+        end
+
+        expect { config.add_filter(filter) { |servers| servers } }.to raise_error(ArgumentError)
+      end
+
+      it "raises an error if the filter lacks a filter method" do
+        filter = Object.new
+        expect { config.add_filter(filter) }.to raise_error(TypeError)
+      end
+
+      it "calls the filter method of a custom filter" do
+        ENV.delete "ROLES"
+        ENV.delete "HOSTS"
+
+        servers = Configuration::Servers.new
+
+        servers.add_host("test1")
+        servers.add_host("test2")
+        servers.add_host("test3")
+
+        filtered_servers = servers.take(2)
+
+        filter = mock("custom filter")
+        filter.expects(:filter)
+              .with { |subset| subset.is_a? Configuration::Servers }
+              .returns(filtered_servers)
+
+        config.add_filter(filter)
+        expect(config.filter(servers)).to eq(filtered_servers)
       end
     end
   end

data/spec/lib/capistrano/doctor/environment_doctor_spec.rb

@@ -0,0 +1,44 @@
+require "spec_helper"
+require "capistrano/doctor/environment_doctor"
+
+module Capistrano
+  module Doctor
+    describe EnvironmentDoctor do
+      let(:doc) { EnvironmentDoctor.new }
+
+      it "prints using 4-space indentation" do
+        expect { doc.call }.to output(/^ {4}/).to_stdout
+      end
+
+      it "prints the Ruby version" do
+        expect { doc.call }.to\
+          output(/#{Regexp.quote(RUBY_DESCRIPTION)}/).to_stdout
+      end
+
+      it "prints the Rubygems version" do
+        expect { doc.call }.to output(/#{Regexp.quote(Gem::VERSION)}/).to_stdout
+      end
+
+      describe "Rake" do
+        before do
+          load File.expand_path("../../../../../lib/capistrano/doctor.rb",
+                                __FILE__)
+        end
+
+        after do
+          Rake::Task.clear
+        end
+
+        it "has an doctor:environment task that calls EnvironmentDoctor", capture_io: true do
+          EnvironmentDoctor.any_instance.expects(:call)
+          Rake::Task["doctor:environment"].invoke
+        end
+
+        it "has a doctor task that depends on doctor:environment" do
+          expect(Rake::Task["doctor"].prerequisites).to \
+            include("doctor:environment")
+        end
+      end
+    end
+  end
+end

data/spec/lib/capistrano/doctor/gems_doctor_spec.rb

@@ -0,0 +1,67 @@
+require "spec_helper"
+require "capistrano/doctor/gems_doctor"
+require "airbrussh/version"
+require "sshkit/version"
+require "net/ssh/version"
+
+module Capistrano
+  module Doctor
+    describe GemsDoctor do
+      let(:doc) { GemsDoctor.new }
+
+      it "prints using 4-space indentation" do
+        expect { doc.call }.to output(/^ {4}/).to_stdout
+      end
+
+      it "prints the Capistrano version" do
+        expect { doc.call }.to\
+          output(/capistrano\s+#{Regexp.quote(Capistrano::VERSION)}/).to_stdout
+      end
+
+      it "prints the Rake version" do
+        expect { doc.call }.to\
+          output(/rake\s+#{Regexp.quote(Rake::VERSION)}/).to_stdout
+      end
+
+      it "prints the SSHKit version" do
+        expect { doc.call }.to\
+          output(/sshkit\s+#{Regexp.quote(SSHKit::VERSION)}/).to_stdout
+      end
+
+      it "prints the Airbrussh version" do
+        expect { doc.call }.to\
+          output(/airbrussh\s+#{Regexp.quote(Airbrussh::VERSION)}/).to_stdout
+      end
+
+      it "prints the net-ssh version" do
+        expect { doc.call }.to\
+          output(/net-ssh\s+#{Regexp.quote(Net::SSH::Version::STRING)}/).to_stdout
+      end
+
+      it "warns that new version is available" do
+        Gem.stubs(:latest_version_for).returns(Gem::Version.new("99.0.0"))
+        expect { doc.call }.to output(/\(update available\)/).to_stdout
+      end
+
+      describe "Rake" do
+        before do
+          load File.expand_path("../../../../../lib/capistrano/doctor.rb",
+                                __FILE__)
+        end
+
+        after do
+          Rake::Task.clear
+        end
+
+        it "has an doctor:gems task that calls GemsDoctor", capture_io: true do
+          GemsDoctor.any_instance.expects(:call)
+          Rake::Task["doctor:gems"].invoke
+        end
+
+        it "has a doctor task that depends on doctor:gems" do
+          expect(Rake::Task["doctor"].prerequisites).to include("doctor:gems")
+        end
+      end
+    end
+  end
+end

data/spec/lib/capistrano/doctor/output_helpers_spec.rb

@@ -0,0 +1,47 @@
+require "spec_helper"
+require "capistrano/doctor/output_helpers"
+
+module Capistrano
+  module Doctor
+    describe OutputHelpers do
+      include OutputHelpers
+
+      # Force color for the purpose of these tests
+      before { ENV.stubs(:[]).with("SSHKIT_COLOR").returns("1") }
+
+      it "prints titles in blue with newlines and without indentation" do
+        expect { title("Hello!") }.to\
+          output("\e[0;34;49m\nHello!\n\e[0m\n").to_stdout
+      end
+
+      it "prints warnings in yellow with 4-space indentation" do
+        expect { warning("Yikes!") }.to\
+          output("    \e[0;33;49mYikes!\e[0m\n").to_stdout
+      end
+
+      it "overrides puts to indent 4 spaces per line" do
+        expect { puts("one\ntwo") }.to output("    one\n    two\n").to_stdout
+      end
+
+      it "formats tables with indent, aligned columns and per-row color" do
+        data = [
+          ["one", ".", "1"],
+          ["two", "..", "2"],
+          ["three", "...", "3"]
+        ]
+        block = proc do |record, row|
+          row.yellow if record.first == "two"
+          row << record[0]
+          row << record[1]
+          row << record[2]
+        end
+        expected_output = <<-OUT
+    one   .   1
+    \e[0;33;49mtwo   ..  2\e[0m
+    three ... 3
+        OUT
+        expect { table(data, &block) }.to output(expected_output).to_stdout
+      end
+    end
+  end
+end

data/spec/lib/capistrano/doctor/servers_doctor_spec.rb

@@ -0,0 +1,86 @@
+require "spec_helper"
+require "capistrano/doctor/servers_doctor"
+
+module Capistrano
+  module Doctor
+    describe ServersDoctor do
+      include Capistrano::DSL
+      let(:doc) { ServersDoctor.new }
+
+      before { Capistrano::Configuration.reset! }
+      after { Capistrano::Configuration.reset! }
+
+      it "prints using 4-space indentation" do
+        expect { doc.call }.to output(/^ {4}/).to_stdout
+      end
+
+      it "prints the number of defined servers" do
+        role :app, %w(example.com)
+        server "www@example.com:22"
+
+        expect { doc.call }.to output(/Servers \(2\)/).to_stdout
+      end
+
+      describe "prints the server's details" do
+        it "including username" do
+          server "www@example.com"
+          expect { doc.call }.to output(/www@example.com/).to_stdout
+        end
+
+        it "including port" do
+          server "www@example.com:22"
+          expect { doc.call }.to output(/www@example.com:22/).to_stdout
+        end
+
+        it "including roles" do
+          role :app, %w(example.com)
+          expect { doc.call }.to output(/example.com\s+\[:app\]/).to_stdout
+        end
+
+        it "including empty roles" do
+          server "example.com"
+          expect { doc.call }.to output(/example.com\s+\[\]/).to_stdout
+        end
+
+        it "including properties" do
+          server "example.com", roles: %w(app db), primary: true
+          expect { doc.call }.to \
+            output(/example.com\s+\[:app, :db\]\s+\{ :primary => true \}/).to_stdout
+        end
+
+        it "including misleading role name alert" do
+          server "example.com", roles: ["web app db"]
+          warning_msg = 'Whitespace detected in role(s) :"web app db". ' \
+            'This might be a result of a mistyped "%w()" array literal'
+
+          expect { doc.call }.to output(/#{Regexp.escape(warning_msg)}/).to_stdout
+        end
+      end
+
+      it "doesn't fail for no servers" do
+        expect { doc.call }.to output("\nServers (0)\n    \n").to_stdout
+      end
+
+      describe "Rake" do
+        before do
+          load File.expand_path("../../../../../lib/capistrano/doctor.rb",
+                                __FILE__)
+        end
+
+        after do
+          Rake::Task.clear
+        end
+
+        it "has an doctor:servers task that calls ServersDoctor", capture_io: true do
+          ServersDoctor.any_instance.expects(:call)
+          Rake::Task["doctor:servers"].invoke
+        end
+
+        it "has a doctor task that depends on doctor:servers" do
+          expect(Rake::Task["doctor"].prerequisites).to \
+            include("doctor:servers")
+        end
+      end
+    end
+  end
+end