capistrano 2.8.0 → 3.19.0

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

@@ -0,0 +1,109 @@
+require "spec_helper"
+
+module Capistrano
+  class Configuration
+    describe Filter do
+      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
+        it "won't create an invalid type of filter" do
+          expect do
+            Filter.new(:zarg)
+          end.to raise_error RuntimeError
+        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
+
+          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
+
+          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
+
+          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
+
+        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
+
+          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 "#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
+
+        context "for an empty filter" do
+          let(:filter) { Filter.new(:role) }
+          it_behaves_like "it calls #filter on its strategy"
+        end
+
+        context "for a null filter" do
+          let(:filter) { Filter.new(:role, :all) }
+          it_behaves_like "it calls #filter on its strategy"
+        end
+
+        context "for a role filter" do
+          let(:filter) { Filter.new(:role, "web") }
+          it_behaves_like "it calls #filter on its strategy"
+        end
+
+        context "for a host filter" do
+          let(:filter) { Filter.new(:host, "server1") }
+          it_behaves_like "it calls #filter on its strategy"
+        end
+      end
+    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

@@ -0,0 +1,92 @@
+require "spec_helper"
+
+module Capistrano
+  class Configuration
+    describe Question do
+      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(:stdin) { stub(tty?: true) }
+
+      describe ".new" do
+        it "takes a key, default, options" do
+          question
+        end
+      end
+
+      describe "#call" do
+        context "value is entered" do
+          let(:branch) { "branch" }
+
+          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
+            $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
+          let(:branch) { default }
+
+          before do
+            $stdout.expects(:print).with("Please enter branch (default): ")
+            stdin.expects(:gets).returns("")
+          end
+
+          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

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

@@ -0,0 +1,80 @@
+require "spec_helper"
+
+module Capistrano
+  class Configuration
+    describe RoleFilter do
+      subject(:role_filter) { RoleFilter.new(values) }
+
+      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),
+          Server.new("server6").add_role(:"db.new")
+        ]
+      end
+
+      shared_examples "it filters roles correctly" do |expected_size, expected|
+        it "filters correctly" do
+          set = role_filter.filter(available)
+          expect(set.size).to eq(expected_size)
+          expect(set.map(&:hostname)).to eq(expected)
+        end
+      end
+
+      describe "#filter" do
+        context "with a single role string" do
+          let(:values) { "web" }
+          it_behaves_like "it filters roles correctly", 2, %w{server1 server2}
+        end
+
+        context "with a single role" do
+          let(:values) { [:web] }
+          it_behaves_like "it filters roles correctly", 2, %w{server1 server2}
+        end
+
+        context "with multiple roles in a string" do
+          let(:values) { "web,db" }
+          it_behaves_like "it filters roles correctly", 3, %w{server1 server2 server4}
+        end
+
+        context "with multiple roles" do
+          let(:values) { %i(web db) }
+          it_behaves_like "it filters roles correctly", 3, %w{server1 server2 server4}
+        end
+
+        context "with a regex" do
+          let(:values) { /red/ }
+          it_behaves_like "it filters roles correctly", 1, %w{server3}
+        end
+
+        context "with a regex string" do
+          let(:values) { "/red|web/" }
+          it_behaves_like "it filters roles correctly", 4, %w{server1 server2 server3 server5}
+        end
+
+        context "with both a string and regex" do
+          let(:values) { "db,/red/" }
+          it_behaves_like "it filters roles correctly", 3, %w{server1 server3 server4}
+        end
+
+        context "with a dot wildcard" do
+          let(:values) { "db.*" }
+          it_behaves_like "it filters roles correctly", 0, %w{}
+        end
+
+        context "with a dot" do
+          let(:values) { "db.new" }
+          it_behaves_like "it filters roles correctly", 1, %w{server6}
+        end
+
+        context "with a dot wildcard regex" do
+          let(:values) { "/db.*/" }
+          it_behaves_like "it filters roles correctly", 3, %w{server1 server4 server6}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+require "spec_helper"
+require "capistrano/scm"
+
+module Capistrano
+  class Configuration
+    describe SCMResolver do
+      include Capistrano::DSL
+
+      let(:resolver) { SCMResolver.new }
+
+      before do
+        Rake::Task.define_task("deploy:check")
+        Rake::Task.define_task("deploy:new_release_path")
+        Rake::Task.define_task("deploy:set_current_revision")
+        Rake::Task.define_task("deploy:set_current_revision_time")
+        set :scm, SCMResolver::DEFAULT_GIT
+      end
+
+      after do
+        Rake::Task.clear
+        Capistrano::Configuration.reset!
+      end
+
+      context "default scm, no plugin installed" do
+        it "emits a warning" do
+          expect { resolver.resolve }.to output(/will not load the git scm/i).to_stderr
+        end
+
+        it "activates the git scm", capture_io: true do
+          resolver.resolve
+          expect(Rake::Task["git:wrapper"]).not_to be_nil
+        end
+
+        it "sets :scm to :git", capture_io: true do
+          resolver.resolve
+          expect(fetch(:scm)).to eq(:git)
+        end
+      end
+
+      context "default scm, git plugin installed" do
+        before do
+          install_plugin Capistrano::SCM::Git
+        end
+
+        it "emits no warning" do
+          expect { resolver.resolve }.not_to output.to_stderr
+        end
+
+        it "deletes :scm" do
+          resolver.resolve
+          expect(fetch(:scm)).to be_nil
+        end
+      end
+    end
+  end
+end