capistrano 2.8.0 → 3.19.0

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

@@ -0,0 +1,228 @@
+require "spec_helper"
+
+describe Capistrano::DSL::Paths do
+  let(:dsl) { Class.new.extend Capistrano::DSL }
+  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 log/access.log} }
+
+  before do
+    dsl.set(:deploy_to, "/var/www")
+  end
+
+  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")
+      ]
+    end
+  end
+
+  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"),
+        Pathname.new("/var/shared/log/access.log")
+      ]
+    end
+  end
+
+  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")
+      ]
+    end
+  end
+
+  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")
+      ]
+    end
+  end
+
+  describe "#release path" do
+    subject { dsl.release_path }
+
+    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"
+      end
+    end
+
+    context "where the release path has been set" do
+      before do
+        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"
+      end
+    end
+  end
+
+  describe "#set_release_path" do
+    let(:now) { Time.parse("Oct 21 16:29:00 2015") }
+    subject { dsl.release_path }
+
+    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"
+      end
+    end
+
+    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
+        paths.expects(:fetch).with(:releases_directory, "releases").returns("test123")
+        paths.expects(:fetch).with(:deploy_to).returns("/var/www")
+      end
+
+      it "returns the releases path with the custom directory" do
+        expect(subject.to_s).to eq "/var/www/test123"
+      end
+    end
+  end
+
+  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
+      before do
+        dsl.delete(:deploy_config_path)
+      end
+
+      it 'returns "config/deploy.rb"' do
+        expect(subject).to eq "config/deploy.rb"
+      end
+    end
+
+    context "when the variable :deploy_config_path is set" do
+      before do
+        dsl.set(:deploy_config_path, "my/custom/path.rb")
+      end
+
+      it "returns the custom path" do
+        expect(subject).to eq "my/custom/path.rb"
+      end
+    end
+  end
+
+  describe "#stage_config_path" do
+    subject { dsl.stage_config_path.to_s }
+
+    context "when not specified" do
+      before do
+        dsl.delete(:stage_config_path)
+      end
+
+      it 'returns "config/deploy"' do
+        expect(subject).to eq "config/deploy"
+      end
+    end
+
+    context "when the variable :stage_config_path is set" do
+      before do
+        dsl.set(:stage_config_path, "my/custom/path")
+      end
+
+      it "returns the custom path" do
+        expect(subject).to eq "my/custom/path"
+      end
+    end
+  end
+
+  describe "#repo_path" do
+    subject { dsl.repo_path.to_s }
+
+    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"
+      end
+    end
+
+    context "when the variable :repo_path is set" do
+      before do
+        dsl.set(:repo_path, "my/custom/path")
+      end
+
+      it "returns the custom path" do
+        expect(subject).to eq "my/custom/path"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+require "spec_helper"
+
+module Capistrano
+  class DummyTaskEnhancements
+    include TaskEnhancements
+  end
+
+  describe TaskEnhancements do
+    let(:task_enhancements) { DummyTaskEnhancements.new }
+
+    describe "ordering" do
+      after do
+        task.clear
+        before_task.clear
+        after_task.clear
+        Rake::Task.clear
+      end
+
+      let(:order) { [] }
+      let!(:task) do
+        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"
+        end
+      end
+
+      let!(:after_task) do
+        Rake::Task.define_task("after_task") do
+          order.push "after_task"
+        end
+      end
+
+      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
+
+        expect(order).to eq(%w(before_task task after_task))
+      end
+
+      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
+
+        expect(order).to eq(%w(before_task task 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")
+
+        Rake::Task.define_task("not_loaded_task") do
+          order.push "not_loaded_task"
+        end
+
+        Rake::Task["task"].invoke order
+
+        expect(order).to eq(%w(task not_loaded_task))
+      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
+
+        task_enhancements.before("task", "before_task_custom", :order) do |_t, _args|
+          order.push "before_task"
+        end
+
+        Rake::Task["task"].invoke(order)
+
+        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 "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
+end

data/spec/lib/capistrano/dsl_spec.rb

@@ -0,0 +1,125 @@
+require "spec_helper"
+
+module Capistrano
+  class DummyDSL
+    include DSL
+  end
+
+  # see also - spec/integration/dsl_spec.rb
+  describe DSL do
+    let(:dsl) { DummyDSL.new }
+
+    describe "#t" do
+      before do
+        I18n.expects(:t).with(:phrase, count: 2, scope: :capistrano)
+      end
+
+      it "delegates to I18n" do
+        dsl.t(:phrase, count: 2)
+      end
+    end
+
+    describe "#stage_set?" do
+      subject { dsl.stage_set? }
+
+      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
+        before do
+          dsl.set(:stage, nil)
+        end
+        it { expect(subject).to be_falsey }
+      end
+    end
+
+    describe "#sudo" do
+      before do
+        dsl.expects(:execute).with(:sudo, :my, :command)
+      end
+
+      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 re-enable 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 re-enable 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

data/spec/lib/capistrano/immutable_task_spec.rb

@@ -0,0 +1,31 @@
+require "spec_helper"
+require "rake"
+require "capistrano/immutable_task"
+
+module Capistrano
+  describe ImmutableTask do
+    after do
+      # Ensure that any tasks we create in these tests don't pollute other tests
+      Rake::Task.clear
+    end
+
+    it "prints warning and raises when task is enhanced" do
+      extend(Rake::DSL)
+
+      load_defaults = Rake::Task.define_task("load:defaults")
+      load_defaults.extend(Capistrano::ImmutableTask)
+
+      $stderr.expects(:puts).with do |message|
+        message =~ /^ERROR: load:defaults has already been invoked/
+      end
+
+      expect do
+        namespace :load do
+          task :defaults do
+            # Never reached since load_defaults is frozen and can't be enhanced
+          end
+        end
+      end.to raise_error(/frozen/i)
+    end
+  end
+end

data/spec/lib/capistrano/plugin_spec.rb

@@ -0,0 +1,84 @@
+require "spec_helper"
+require "capistrano/plugin"
+
+module Capistrano
+  describe Plugin do
+    include Rake::DSL
+    include Capistrano::DSL
+
+    class DummyPlugin < Capistrano::Plugin
+      def define_tasks
+        task :hello do
+        end
+      end
+
+      def register_hooks
+        before "deploy:published", "hello"
+      end
+    end
+
+    class ExternalTasksPlugin < Capistrano::Plugin
+      def define_tasks
+        eval_rakefile(
+          File.expand_path("../../../support/tasks/plugin.rake", __FILE__)
+        )
+      end
+
+      # Called from plugin.rake to demonstrate that helper methods work
+      def hello
+        set :plugin_result, "hello"
+      end
+    end
+
+    before do
+      # Define an example task to allow testing hooks
+      task "deploy:published"
+    end
+
+    after do
+      # Clean up any tasks or variables we created during the tests
+      Rake::Task.clear
+      Capistrano::Configuration.reset!
+    end
+
+    it "defines tasks when constructed" do
+      install_plugin(DummyPlugin)
+      expect(Rake::Task["hello"]).not_to be_nil
+    end
+
+    it "registers hooks when constructed" do
+      install_plugin(DummyPlugin)
+      expect(Rake::Task["deploy:published"].prerequisites).to include("hello")
+    end
+
+    it "skips registering hooks if load_hooks: false" do
+      install_plugin(DummyPlugin, load_hooks: false)
+      expect(Rake::Task["deploy:published"].prerequisites).to be_empty
+    end
+
+    it "doesn't call set_defaults immediately" do
+      dummy = DummyPlugin.new
+      install_plugin(dummy)
+      dummy.expects(:set_defaults).never
+    end
+
+    it "calls set_defaults during load:defaults", capture_io: true do
+      dummy = DummyPlugin.new
+      dummy.expects(:set_defaults).once
+      install_plugin(dummy)
+      Rake::Task["load:defaults"].invoke
+    end
+
+    it "is able to load tasks from a .rake file", capture_io: true do
+      install_plugin(ExternalTasksPlugin)
+      Rake::Task["plugin_test"].invoke
+      expect(fetch(:plugin_result)).to eq("hello")
+    end
+
+    it "exposes the SSHKit backend to subclasses" do
+      SSHKit::Backend.expects(:current).returns(:backend)
+      plugin = DummyPlugin.new
+      expect(plugin.send(:backend)).to eq(:backend)
+    end
+  end
+end