capistrano 3.4.0 → 3.17.1

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,55 @@
+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")
+        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

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

@@ -1,141 +1,139 @@
-require 'spec_helper'
+require "spec_helper"
 
 module Capistrano
   class Configuration
     describe Server do
-      let(:server) { Server.new('root@hostname:1234') }
+      let(:server) { Server.new("root@hostname:1234") }
 
-      describe 'adding a role' do
+      describe "adding a role" do
         subject { server.add_role(:test) }
-        it 'adds the role' do
-          expect{subject}.to change{server.roles.size}.from(0).to(1)
+        it "adds the role" do
+          expect { subject }.to change { server.roles.size }.from(0).to(1)
         end
       end
 
-      describe 'adding roles' do
-        subject { server.add_roles([:things, :stuff]) }
-        it 'adds the roles' do
-          expect{subject}.to change{server.roles.size}.from(0).to(2)
+      describe "adding roles" do
+        subject { server.add_roles(%i(things stuff)) }
+        it "adds the roles" do
+          expect { subject }.to change { server.roles.size }.from(0).to(2)
         end
       end
 
-
-      describe 'checking roles' do
+      describe "checking roles" do
         subject { server.has_role?(:test) }
 
         before do
           server.add_role(:test)
         end
 
-        it 'adds the role' do
+        it "adds the role" do
           expect(subject).to be_truthy
         end
       end
 
-      describe 'comparing identity' do
+      describe "comparing identity" do
         subject { server.hostname == Server[hostname].hostname }
 
-        context 'with the same user, hostname and port' do
-          let(:hostname) { 'root@hostname:1234' }
+        context "with the same user, hostname and port" do
+          let(:hostname) { "root@hostname:1234" }
           it { expect(subject).to be_truthy }
         end
 
-        context 'with a different user' do
-          let(:hostname) { 'deployer@hostname:1234' }
+        context "with a different user" do
+          let(:hostname) { "deployer@hostname:1234" }
           it { expect(subject).to be_truthy }
         end
 
-        context 'with a different port' do
-          let(:hostname) { 'root@hostname:5678' }
+        context "with a different port" do
+          let(:hostname) { "root@hostname:5678" }
           it { expect(subject).to be_truthy }
         end
 
-        context 'with a different hostname' do
-          let(:hostname) { 'root@otherserver:1234' }
+        context "with a different hostname" do
+          let(:hostname) { "root@otherserver:1234" }
           it { expect(subject).to be_falsey }
         end
       end
 
-      describe 'identifying as primary' do
+      describe "identifying as primary" do
         subject { server.primary }
-        context 'server is primary' do
+        context "server is primary" do
           before do
             server.set(:primary, true)
           end
-          it 'returns self' do
+          it "returns self" do
             expect(subject).to eq server
           end
         end
 
-        context 'server is not primary' do
-          it 'is falesy' do
+        context "server is not primary" do
+          it "is falesy" do
             expect(subject).to be_falsey
           end
         end
       end
 
-      describe 'assigning properties' do
-
+      describe "assigning properties" do
         before do
           server.with(properties)
         end
 
-        context 'properties contains roles' do
-          let(:properties) { {roles: [:clouds]} }
+        context "properties contains roles" do
+          let(:properties) { { roles: [:clouds] } }
 
-          it 'adds the roles' do
+          it "adds the roles" do
             expect(server.roles.first).to eq :clouds
           end
         end
 
-        context 'properties contains user' do
-          let(:properties) { {user: 'tomc'} }
+        context "properties contains user" do
+          let(:properties) { { user: "tomc" } }
 
-          it 'sets the user' do
-            expect(server.user).to eq 'tomc'
+          it "sets the user" do
+            expect(server.user).to eq "tomc"
           end
 
-          it 'sets the netssh_options user' do
-            expect(server.netssh_options[:user]).to eq 'tomc'
+          it "sets the netssh_options user" do
+            expect(server.netssh_options[:user]).to eq "tomc"
           end
         end
 
-        context 'properties contains port' do
-          let(:properties) { {port: 2222} }
+        context "properties contains port" do
+          let(:properties) { { port: 2222 } }
 
-          it 'sets the port' do
+          it "sets the port" do
             expect(server.port).to eq 2222
           end
         end
 
-        context 'properties contains key' do
-          let(:properties) { {key: '/key'} }
+        context "properties contains key" do
+          let(:properties) { { key: "/key" } }
 
-          it 'adds the key' do
-            expect(server.keys).to include '/key'
+          it "adds the key" do
+            expect(server.keys).to include "/key"
           end
         end
 
-        context 'properties contains password' do
-          let(:properties) { {password: 'supersecret'} }
+        context "properties contains password" do
+          let(:properties) { { password: "supersecret" } }
 
-          it 'adds the key' do
-            expect(server.password).to eq 'supersecret'
+          it "adds the key" do
+            expect(server.password).to eq "supersecret"
           end
         end
 
-        context 'new properties' do
+        context "new properties" do
           let(:properties) { { webscales: 5 } }
 
-          it 'adds the properties' do
+          it "adds the properties" do
             expect(server.properties.webscales).to eq 5
           end
         end
 
-        context 'existing properties' do
+        context "existing properties" do
           let(:properties) { { webscales: 6 } }
 
-          it 'keeps the existing properties' do
+          it "keeps the existing properties" do
             expect(server.properties.webscales).to eq 6
             server.properties.webscales = 5
             expect(server.properties.webscales).to eq 5
@@ -143,7 +141,7 @@ module Capistrano
         end
       end
 
-      describe '#include?' do
+      describe "#include?" do
         let(:options) { {} }
 
         subject { server.select?(options) }
@@ -152,162 +150,157 @@ module Capistrano
           server.properties.active = true
         end
 
-        context 'options are empty' do
+        context "options are empty" do
           it { expect(subject).to be_truthy }
         end
 
-        context 'value is a symbol' do
-          context 'value matches server property' do
-
-            context 'with :filter' do
-              let(:options) { { filter: :active }}
+        context "value is a symbol" do
+          context "value matches server property" do
+            context "with :filter" do
+              let(:options) { { filter: :active } }
               it { expect(subject).to be_truthy }
             end
 
-            context 'with :select' do
-              let(:options) { { select: :active }}
+            context "with :select" do
+              let(:options) { { select: :active } }
               it { expect(subject).to be_truthy }
             end
 
-            context 'with :exclude' do
-              let(:options) { { exclude: :active }}
+            context "with :exclude" do
+              let(:options) { { exclude: :active } }
               it { expect(subject).to be_falsey }
             end
           end
 
-          context 'value does not match server properly' do
-            context 'with :active true' do
-              let(:options) { { active: true }}
+          context "value does not match server properly" do
+            context "with :active true" do
+              let(:options) { { active: true } }
               it { expect(subject).to be_truthy }
             end
 
-            context 'with :active false' do
-              let(:options) { { active: false }}
+            context "with :active false" do
+              let(:options) { { active: false } }
               it { expect(subject).to be_falsey }
             end
           end
 
-          context 'value does not match server properly' do
-            context 'with :filter' do
-              let(:options) { { filter: :inactive }}
+          context "value does not match server properly" do
+            context "with :filter" do
+              let(:options) { { filter: :inactive } }
               it { expect(subject).to be_falsey }
             end
 
-            context 'with :select' do
-              let(:options) { { select: :inactive }}
+            context "with :select" do
+              let(:options) { { select: :inactive } }
               it { expect(subject).to be_falsey }
             end
 
-            context 'with :exclude' do
-              let(:options) { { exclude: :inactive }}
+            context "with :exclude" do
+              let(:options) { { exclude: :inactive } }
               it { expect(subject).to be_truthy }
             end
           end
         end
 
-        context 'key is a property' do
-          context 'with :active true' do
-            let(:options) { { active: true }}
+        context "key is a property" do
+          context "with :active true" do
+            let(:options) { { active: true } }
             it { expect(subject).to be_truthy }
           end
 
-          context 'with :active false' do
-            let(:options) { { active: false }}
+          context "with :active false" do
+            let(:options) { { active: false } }
             it { expect(subject).to be_falsey }
           end
         end
 
-        context 'value is a proc' do
-          context 'value matches server property' do
-
-            context 'with :filter' do
+        context "value is a proc" do
+          context "value matches server property" do
+            context "with :filter" do
               let(:options) { { filter: ->(s) { s.properties.active } } }
               it { expect(subject).to be_truthy }
             end
 
-            context 'with :select' do
+            context "with :select" do
               let(:options) { { select: ->(s) { s.properties.active } } }
               it { expect(subject).to be_truthy }
             end
 
-            context 'with :exclude' do
+            context "with :exclude" do
               let(:options) { { exclude: ->(s) { s.properties.active } } }
               it { expect(subject).to be_falsey }
             end
-
           end
 
-          context 'value does not match server properly' do
-            context 'with :filter' do
+          context "value does not match server properly" do
+            context "with :filter" do
               let(:options) { { filter: ->(s) { s.properties.inactive } } }
               it { expect(subject).to be_falsey }
             end
 
-            context 'with :select' do
+            context "with :select" do
               let(:options) { { select: ->(s) { s.properties.inactive } } }
               it { expect(subject).to be_falsey }
             end
 
-            context 'with :exclude' do
+            context "with :exclude" do
               let(:options) { { exclude: ->(s) { s.properties.inactive } } }
               it { expect(subject).to be_truthy }
             end
-
           end
         end
-
       end
 
-      describe 'assign ssh_options' do
-        let(:server) { Server.new('user_name@hostname') }
+      describe "assign ssh_options" do
+        let(:server) { Server.new("user_name@hostname") }
 
-        context 'defaults' do
-          it 'forward agent' do
+        context "defaults" do
+          it "forward agent" do
             expect(server.netssh_options[:forward_agent]).to eq true
           end
-          it 'contains user' do
-            expect(server.netssh_options[:user]).to eq 'user_name'
+          it "contains user" do
+            expect(server.netssh_options[:user]).to eq "user_name"
           end
         end
 
-        context 'custom' do
+        context "custom" do
           let(:properties) do
             { ssh_options: {
-              user: 'another_user',
+              user: "another_user",
               keys: %w(/home/another_user/.ssh/id_rsa),
               forward_agent: false,
-              auth_methods: %w(publickey password) } }
+              auth_methods: %w(publickey password)
+            } }
           end
 
           before do
             server.with(properties)
           end
 
-          it 'not forward agent' do
+          it "not forward agent" do
             expect(server.netssh_options[:forward_agent]).to eq false
           end
-          it 'contains correct user' do
-            expect(server.netssh_options[:user]).to eq 'another_user'
+          it "contains correct user" do
+            expect(server.netssh_options[:user]).to eq "another_user"
           end
-          it 'does not affect server user in host' do
-            expect(server.user).to eq 'user_name'
+          it "does not affect server user in host" do
+            expect(server.user).to eq "user_name"
           end
-          it 'contains keys' do
+          it "contains keys" do
             expect(server.netssh_options[:keys]).to eq %w(/home/another_user/.ssh/id_rsa)
           end
-          it 'contains auth_methods' do
+          it "contains auth_methods" do
             expect(server.netssh_options[:auth_methods]).to eq %w(publickey password)
           end
         end
-
       end
 
       describe ".[]" do
-        it 'creates a server if its argument is not already a server' do
-          expect(Server['hostname:1234']).to be_a Server
+        it "creates a server if its argument is not already a server" do
+          expect(Server["hostname:1234"]).to be_a Server
         end
 
-        it 'returns its argument if it is already a server' do
+        it "returns its argument if it is already a server" do
           expect(Server[server]).to be server
         end
       end