capistrano 2.8.0 → 3.19.0

data/spec/lib/capistrano/configuration_spec.rb

@@ -0,0 +1,357 @@
+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")
+      end
+    end
+
+    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
+        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}) }
+
+        before do
+          Configuration::Servers.expects(:new).returns(servers)
+          servers.expects(:add_role).with(:app, %w{server1 server2}, {})
+        end
+
+        it "adds the role" do
+          expect(subject)
+        end
+      end
+    end
+
+    describe "setting and fetching" do
+      subject { config.fetch(:key, :default) }
+
+      context "set" do
+        it "sets by value" do
+          config.set(:key, :value)
+          expect(subject).to eq :value
+        end
+
+        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 by value when none is present" do
+          config.set_if_empty(:key, :value)
+          expect(subject).to eq :value
+        end
+
+        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
+          expect(subject).to eq :default
+        end
+      end
+
+      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 }) }
+        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 { 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, -> { -> { "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 { -> { "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, -> { 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, ->(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) { 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 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
+      subject { config.keys }
+
+      before do
+        config.set(:key1, :value1)
+        config.set(:key2, :value2)
+      end
+
+      it "returns all set keys" do
+        expect(subject).to match_array %i(key1 key2)
+      end
+    end
+
+    describe "deleting" do
+      before do
+        config.set(:key, :value)
+      end
+
+      it "deletes the value" do
+        config.delete(:key)
+        expect(config.fetch(:key)).to be_nil
+      end
+    end
+
+    describe "asking" do
+      let(:question) { stub }
+      let(:options) { {} }
+
+      before do
+        Configuration::Question.expects(:new).with(:branch, :default, options)
+                               .returns(question)
+      end
+
+      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
+        expect(config.backend).to eq SSHKit
+      end
+
+      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
+          config.set :format, :pretty
+          config.set :log_level, :debug
+          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 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
+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

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

@@ -0,0 +1,89 @@
+require "spec_helper"
+require "capistrano/doctor/variables_doctor"
+
+module Capistrano
+  module Doctor
+    describe VariablesDoctor do
+      include Capistrano::DSL
+
+      let(:doc) { VariablesDoctor.new }
+
+      before do
+        set :branch, "master"
+        set :pty, false
+
+        env.variables.untrusted! do
+          set :application, "my_app"
+          set :repo_tree, "public"
+          set :repo_url, ".git"
+          set :copy_strategy, :scp
+          set :custom_setting, "hello"
+          set "string_setting", "hello"
+          ask :secret
+        end
+
+        fetch :custom_setting
+      end
+
+      after { Capistrano::Configuration.reset! }
+
+      it "prints using 4-space indentation" do
+        expect { doc.call }.to output(/^ {4}/).to_stdout
+      end
+
+      it "prints variable names and values" do
+        expect { doc.call }.to output(/:branch\s+"master"$/).to_stdout
+        expect { doc.call }.to output(/:pty\s+false$/).to_stdout
+        expect { doc.call }.to output(/:application\s+"my_app"$/).to_stdout
+        expect { doc.call }.to output(/:repo_url\s+".git"$/).to_stdout
+        expect { doc.call }.to output(/:repo_tree\s+"public"$/).to_stdout
+        expect { doc.call }.to output(/:copy_strategy\s+:scp$/).to_stdout
+        expect { doc.call }.to output(/:custom_setting\s+"hello"$/).to_stdout
+        expect { doc.call }.to output(/"string_setting"\s+"hello"$/).to_stdout
+      end
+
+      it "prints unanswered question variable as <ask>" do
+        expect { doc.call }.to output(/:secret\s+<ask>$/).to_stdout
+      end
+
+      it "prints warning for unrecognized variable" do
+        expect { doc.call }.to \
+          output(/:copy_strategy is not a recognized Capistrano setting/)\
+          .to_stdout
+      end
+
+      it "does not print warning for unrecognized variable that is fetched" do
+        expect { doc.call }.not_to \
+          output(/:custom_setting is not a recognized Capistrano setting/)\
+          .to_stdout
+      end
+
+      it "does not print warning for whitelisted variable" do
+        expect { doc.call }.not_to \
+          output(/:repo_tree is not a recognized Capistrano setting/)\
+          .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:variables task that calls VariablesDoctor", capture_io: true do
+          VariablesDoctor.any_instance.expects(:call)
+          Rake::Task["doctor:variables"].invoke
+        end
+
+        it "has a doctor task that depends on doctor:variables" do
+          expect(Rake::Task["doctor"].prerequisites).to \
+            include("doctor:variables")
+        end
+      end
+    end
+  end
+end