capistrano 3.4.0 → 3.17.1

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

data/spec/lib/capistrano/dsl/paths_spec.rb

@@ -1,189 +1,227 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Capistrano::DSL::Paths do
-
   let(:dsl) { Class.new.extend Capistrano::DSL }
-  let(:parent) { Pathname.new('/var/shared') }
+  let(:parent) { Pathname.new("/var/shared") }
   let(:paths) { Class.new.extend Capistrano::DSL::Paths }
 
   let(:linked_dirs) { %w{log public/system} }
-  let(:linked_files) { %w{config/database.yml log/my.log} }
+  let(:linked_files) { %w{config/database.yml log/my.log log/access.log} }
 
   before do
-    dsl.set(:deploy_to, '/var/www')
+    dsl.set(:deploy_to, "/var/www")
   end
 
-  describe '#linked_dirs' do
+  describe "#linked_dirs" do
     subject { paths.linked_dirs(parent) }
 
     before do
       paths.expects(:fetch).with(:linked_dirs).returns(linked_dirs)
     end
 
-    it 'returns the full pathnames' do
-      expect(subject).to eq [Pathname.new('/var/shared/log'), Pathname.new('/var/shared/public/system')]
+    it "returns the full pathnames" do
+      expect(subject).to eq [
+        Pathname.new("/var/shared/log"),
+        Pathname.new("/var/shared/public/system")
+      ]
     end
   end
 
-
-  describe '#linked_files' do
+  describe "#linked_files" do
     subject { paths.linked_files(parent) }
 
     before do
       paths.expects(:fetch).with(:linked_files).returns(linked_files)
     end
 
-    it 'returns the full pathnames' do
-      expect(subject).to eq [Pathname.new('/var/shared/config/database.yml'), Pathname.new('/var/shared/log/my.log')]
+    it "returns the full pathnames" do
+      expect(subject).to eq [
+        Pathname.new("/var/shared/config/database.yml"),
+        Pathname.new("/var/shared/log/my.log"),
+        Pathname.new("/var/shared/log/access.log")
+      ]
     end
   end
 
-  describe '#linked_file_dirs' do
+  describe "#linked_file_dirs" do
     subject { paths.linked_file_dirs(parent) }
 
     before do
       paths.expects(:fetch).with(:linked_files).returns(linked_files)
     end
 
-    it 'returns the full paths names of the parent dirs' do
-      expect(subject).to eq [Pathname.new('/var/shared/config'), Pathname.new('/var/shared/log')]
+    it "returns the full paths names of the parent dirs" do
+      expect(subject).to eq [
+        Pathname.new("/var/shared/config"),
+        Pathname.new("/var/shared/log")
+      ]
     end
   end
 
-  describe '#linked_dir_parents' do
+  describe "#linked_dir_parents" do
     subject { paths.linked_dir_parents(parent) }
 
     before do
       paths.expects(:fetch).with(:linked_dirs).returns(linked_dirs)
     end
 
-    it 'returns the full paths names of the parent dirs' do
-      expect(subject).to eq [Pathname.new('/var/shared'), Pathname.new('/var/shared/public')]
+    it "returns the full paths names of the parent dirs" do
+      expect(subject).to eq [
+        Pathname.new("/var/shared"),
+        Pathname.new("/var/shared/public")
+      ]
     end
   end
 
-  describe '#release path' do
-
+  describe "#release path" do
     subject { dsl.release_path }
 
-    context 'where no release path has been set' do
+    context "where no release path has been set" do
       before do
         dsl.delete(:release_path)
       end
 
-      it 'returns the `current_path` value' do
-        expect(subject.to_s).to eq '/var/www/current'
+      it "returns the `current_path` value" do
+        expect(subject.to_s).to eq "/var/www/current"
       end
     end
 
-    context 'where the release path has been set' do
+    context "where the release path has been set" do
       before do
-        dsl.set(:release_path,'/var/www/release_path')
+        dsl.set(:release_path, "/var/www/release_path")
       end
 
-      it 'returns the set `release_path` value' do
-        expect(subject.to_s).to eq '/var/www/release_path'
+      it "returns the set `release_path` value" do
+        expect(subject.to_s).to eq "/var/www/release_path"
       end
     end
   end
 
-  describe '#set_release_path' do
+  describe "#set_release_path" do
     let(:now) { Time.parse("Oct 21 16:29:00 2015") }
     subject { dsl.release_path }
 
-    context 'without a timestamp' do
+    context "without a timestamp" do
       before do
         dsl.env.expects(:timestamp).returns(now)
         dsl.set_release_path
       end
 
-      it 'returns the release path with the current env timestamp' do
-        expect(subject.to_s).to eq '/var/www/releases/20151021162900'
+      it "returns the release path with the current env timestamp" do
+        expect(subject.to_s).to eq "/var/www/releases/20151021162900"
       end
     end
 
-    context 'with a timestamp' do
+    context "with a timestamp" do
+      before do
+        dsl.set_release_path("timestamp")
+      end
+
+      it "returns the release path with the timestamp" do
+        expect(subject.to_s).to eq "/var/www/releases/timestamp"
+      end
+    end
+  end
+
+  describe "#releases_path" do
+    subject { paths.releases_path }
+
+    context "with custom releases directory" do
       before do
-        dsl.set_release_path('timestamp')
+        paths.expects(:fetch).with(:releases_directory, "releases").returns("test123")
+        paths.expects(:fetch).with(:deploy_to).returns("/var/www")
       end
 
-      it 'returns the release path with the timestamp' do
-        expect(subject.to_s).to eq '/var/www/releases/timestamp'
+      it "returns the releases path with the custom directory" do
+        expect(subject.to_s).to eq "/var/www/test123"
       end
     end
   end
 
-  describe '#deploy_config_path' do
+  describe "#shared_path" do
+    subject { paths.shared_path }
+
+    context "with custom shared directory" do
+      before do
+        paths.expects(:fetch).with(:shared_directory, "shared").returns("test123")
+        paths.expects(:fetch).with(:deploy_to).returns("/var/www")
+      end
+
+      it "returns the shared path with the custom directory" do
+        expect(subject.to_s).to eq "/var/www/test123"
+      end
+    end
+  end
+
+  describe "#deploy_config_path" do
     subject { dsl.deploy_config_path.to_s }
 
-    context 'when not specified' do
+    context "when not specified" do
       before do
         dsl.delete(:deploy_config_path)
       end
 
       it 'returns "config/deploy.rb"' do
-        expect(subject).to eq 'config/deploy.rb'
+        expect(subject).to eq "config/deploy.rb"
       end
     end
 
-    context 'when the variable :deploy_config_path is set' do
+    context "when the variable :deploy_config_path is set" do
       before do
-        dsl.set(:deploy_config_path, 'my/custom/path.rb')
+        dsl.set(:deploy_config_path, "my/custom/path.rb")
       end
 
-      it 'returns the custom path' do
-        expect(subject).to eq 'my/custom/path.rb'
+      it "returns the custom path" do
+        expect(subject).to eq "my/custom/path.rb"
       end
     end
   end
 
-  describe '#stage_config_path' do
+  describe "#stage_config_path" do
     subject { dsl.stage_config_path.to_s }
 
-    context 'when not specified' do
-
+    context "when not specified" do
       before do
         dsl.delete(:stage_config_path)
       end
 
       it 'returns "config/deploy"' do
-        expect(subject).to eq 'config/deploy'
+        expect(subject).to eq "config/deploy"
       end
     end
 
-    context 'when the variable :stage_config_path is set' do
+    context "when the variable :stage_config_path is set" do
       before do
-        dsl.set(:stage_config_path, 'my/custom/path')
+        dsl.set(:stage_config_path, "my/custom/path")
       end
 
-      it 'returns the custom path' do
-        expect(subject).to eq 'my/custom/path'
+      it "returns the custom path" do
+        expect(subject).to eq "my/custom/path"
       end
     end
   end
 
-  describe '#repo_path' do
+  describe "#repo_path" do
     subject { dsl.repo_path.to_s }
 
-    context 'when not specified' do
-
+    context "when not specified" do
       before do
         dsl.delete(:repo_path)
       end
 
       it 'returns the default #{deploy_to}/repo' do
-        dsl.set(:deploy_to, '/var/www')
-        expect(subject).to eq '/var/www/repo'
+        dsl.set(:deploy_to, "/var/www")
+        expect(subject).to eq "/var/www/repo"
       end
     end
 
-    context 'when the variable :repo_path is set' do
+    context "when the variable :repo_path is set" do
       before do
-        dsl.set(:repo_path, 'my/custom/path')
+        dsl.set(:repo_path, "my/custom/path")
       end
 
-      it 'returns the custom path' do
-        expect(subject).to eq 'my/custom/path'
+      it "returns the custom path" do
+        expect(subject).to eq "my/custom/path"
       end
     end
   end

data/spec/lib/capistrano/dsl/task_enhancements_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 module Capistrano
   class DummyTaskEnhancements
@@ -8,8 +8,7 @@ module Capistrano
   describe TaskEnhancements do
     let(:task_enhancements) { DummyTaskEnhancements.new }
 
-    describe 'ordering' do
-
+    describe "ordering" do
       after do
         task.clear
         before_task.clear
@@ -19,69 +18,90 @@ module Capistrano
 
       let(:order) { [] }
       let!(:task) do
-        Rake::Task.define_task('task', [:order]) do |t, args|
-          args['order'].push 'task'
+        Rake::Task.define_task("task", [:order]) do |_t, args|
+          args["order"].push "task"
         end
       end
 
       let!(:before_task) do
-        Rake::Task.define_task('before_task') do
-          order.push 'before_task'
+        Rake::Task.define_task("before_task") do
+          order.push "before_task"
         end
       end
 
       let!(:after_task) do
-        Rake::Task.define_task('after_task') do
-          order.push 'after_task'
+        Rake::Task.define_task("after_task") do
+          order.push "after_task"
         end
       end
 
-      it 'invokes in proper order if define after than before' do
-        task_enhancements.after('task', 'after_task')
-        task_enhancements.before('task', 'before_task')
+      it "invokes in proper order if define after than before", capture_io: true do
+        task_enhancements.after("task", "after_task")
+        task_enhancements.before("task", "before_task")
 
-        Rake::Task['task'].invoke order
+        Rake::Task["task"].invoke order
 
-        expect(order).to eq(['before_task', 'task', 'after_task'])
+        expect(order).to eq(%w(before_task task after_task))
       end
 
-      it 'invokes in proper order if define before than after' do
-        task_enhancements.before('task', 'before_task')
-        task_enhancements.after('task', 'after_task')
+      it "invokes in proper order if define before than after", capture_io: true do
+        task_enhancements.before("task", "before_task")
+        task_enhancements.after("task", "after_task")
 
-        Rake::Task['task'].invoke order
+        Rake::Task["task"].invoke order
 
-        expect(order).to eq(['before_task', 'task', 'after_task'])
+        expect(order).to eq(%w(before_task task after_task))
       end
 
-      it 'invokes in proper order and with arguments and block' do
-        task_enhancements.after('task', 'after_task_custom', :order) do |t, args|
-          order.push 'after_task'
-        end
+      it "invokes in proper order when referring to as-yet undefined tasks", capture_io: true do
+        task_enhancements.after("task", "not_loaded_task")
 
-        task_enhancements.before('task', 'before_task_custom', :order) do |t, args|
-          order.push 'before_task'
+        Rake::Task.define_task("not_loaded_task") do
+          order.push "not_loaded_task"
         end
 
-        Rake::Task['task'].invoke(order)
+        Rake::Task["task"].invoke order
 
-        expect(order).to eq(['before_task', 'task', 'after_task'])
+        expect(order).to eq(%w(task not_loaded_task))
       end
 
-    end
+      it "invokes in proper order and with arguments and block", capture_io: true do
+        task_enhancements.after("task", "after_task_custom", :order) do |_t, _args|
+          order.push "after_task"
+        end
 
-    describe 'remote_file' do
-      subject(:remote_file) { task_enhancements.remote_file('source' => 'destination') }
+        task_enhancements.before("task", "before_task_custom", :order) do |_t, _args|
+          order.push "before_task"
+        end
 
-      it { expect(remote_file.name).to eq('source') }
-      it { is_expected.to be_a(Capistrano::UploadTask) }
+        Rake::Task["task"].invoke(order)
 
-      describe 'namespaced' do
-        let(:app) { Rake.application }
-        around { |ex| app.in_namespace('namespace', &ex) }
+        expect(order).to eq(%w(before_task task after_task))
+      end
+
+      it "invokes using the correct namespace when defined within a namespace", capture_io: true do
+        Rake.application.in_namespace("namespace") do
+          Rake::Task.define_task("task") do |t|
+            order.push(t.name)
+          end
+          task_enhancements.before("task", "before_task", :order) do |t|
+            order.push(t.name)
+          end
+          task_enhancements.after("task", "after_task", :order) do |t|
+            order.push(t.name)
+          end
+        end
+
+        Rake::Task["namespace:task"].invoke
+
+        expect(order).to eq(
+          ["namespace:before_task", "namespace:task", "namespace:after_task"]
+        )
+      end
 
-        it { expect(remote_file.name).to eq('source') }
-        it { is_expected.to be_a(Capistrano::UploadTask) }
+      it "raises a sensible error if the task isn't found", capture_io: true do
+        task_enhancements.after("task", "non_existent_task")
+        expect { Rake::Task["task"].invoke order }.to raise_error(ArgumentError, 'Task "non_existent_task" not found')
       end
     end
   end

data/spec/lib/capistrano/dsl_spec.rb

@@ -1,7 +1,6 @@
-require 'spec_helper'
+require "spec_helper"
 
 module Capistrano
-
   class DummyDSL
     include DSL
   end
@@ -10,27 +9,27 @@ module Capistrano
   describe DSL do
     let(:dsl) { DummyDSL.new }
 
-    describe '#t' do
+    describe "#t" do
       before do
-        I18n.expects(:t).with(:phrase, {count: 2, scope: :capistrano})
+        I18n.expects(:t).with(:phrase, count: 2, scope: :capistrano)
       end
 
-      it 'delegates to I18n' do
+      it "delegates to I18n" do
         dsl.t(:phrase, count: 2)
       end
     end
 
-    describe '#stage_set?' do
+    describe "#stage_set?" do
       subject { dsl.stage_set? }
 
-      context 'stage is set' do
+      context "stage is set" do
         before do
           dsl.set(:stage, :sandbox)
         end
         it { expect(subject).to be_truthy }
       end
 
-      context 'stage is not set' do
+      context "stage is not set" do
         before do
           dsl.set(:stage, nil)
         end
@@ -38,15 +37,89 @@ module Capistrano
       end
     end
 
-    describe '#sudo' do
-
+    describe "#sudo" do
       before do
         dsl.expects(:execute).with(:sudo, :my, :command)
       end
 
-      it 'prepends sudo, delegates to execute' do
+      it "prepends sudo, delegates to execute" do
         dsl.sudo(:my, :command)
       end
     end
+
+    describe "#execute" do
+      context "use outside of on scope" do
+        after do
+          task.clear
+          Rake::Task.clear
+        end
+
+        let(:task) do
+          Rake::Task.define_task("execute_outside_scope") do
+            dsl.execute "whoami"
+          end
+        end
+
+        it "prints helpful message to stderr", capture_io: true do
+          expect do
+            expect do
+              task.invoke
+            end.to output(/^.*Warning: `execute' should be wrapped in an `on' scope/).to_stderr
+          end.to raise_error(NoMethodError)
+        end
+      end
+    end
+
+    describe "#invoke" do
+      context "reinvoking" do
+        it "will not reenable invoking task", capture_io: true do
+          counter = 0
+
+          Rake::Task.define_task("A") do
+            counter += 1
+          end
+
+          expect do
+            dsl.invoke("A")
+            dsl.invoke("A")
+          end.to change { counter }.by(1)
+        end
+
+        it "will print a message on stderr", capture_io: true do
+          Rake::Task.define_task("B")
+
+          expect do
+            dsl.invoke("B")
+            dsl.invoke("B")
+          end.to output(/If you really meant to run this task again, use invoke!/).to_stderr
+        end
+      end
+    end
+
+    describe "#invoke!" do
+      context "reinvoking" do
+        it "will reenable invoking task", capture_io: true do
+          counter = 0
+
+          Rake::Task.define_task("C") do
+            counter += 1
+          end
+
+          expect do
+            dsl.invoke!("C")
+            dsl.invoke!("C")
+          end.to change { counter }.by(2)
+        end
+
+        it "will not print a message on stderr", capture_io: true do
+          Rake::Task.define_task("D")
+
+          expect do
+            dsl.invoke!("D")
+            dsl.invoke!("D")
+          end.to_not output(/If you really meant to run this task again, use invoke!/).to_stderr
+        end
+      end
+    end
   end
 end