capistrano 3.3.5 → 3.4.0

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

@@ -7,7 +7,8 @@ module Capistrano
       let(:available) { [ Server.new('server1').add_roles([:web,:db]),
                           Server.new('server2').add_role(:web),
                           Server.new('server3').add_role(:redis),
-                          Server.new('server4').add_role(:db) ] }
+                          Server.new('server4').add_role(:db),
+                          Server.new('server5').add_role(:stageweb) ] }
 
       describe '#new' do
         it "won't create an invalid type of filter" do
@@ -57,7 +58,7 @@ module Capistrano
         end
         it 'correctly identifies a regex with a comma in' do
           set = Filter.new(:host, 'server\d{1,3}$').filter(available)
-          expect(set.map(&:hostname)).to eq(%w{server1 server2 server3 server4})
+          expect(set.map(&:hostname)).to eq(%w{server1 server2 server3 server4 server5})
         end
       end
 
@@ -87,13 +88,18 @@ module Capistrano
           expect(set.size).to eq(3)
           expect(set.map(&:hostname)).to eq(%w{server1 server2 server4})
         end
+        it 'returns only hosts for explicit roles' do
+          set = Filter.new(:role, [:web]).filter(available)
+          expect(set.size).to eq(2)
+          expect(set.map(&:hostname)).to eq(%w{server1 server2})
+        end
         it 'returns hosts with regex role selection' do
           set = Filter.new(:role, /red/).filter(available)
           expect(set.map(&:hostname)).to eq(%w{server3})
         end
         it 'returns hosts with regex role selection using a string' do
           set = Filter.new(:role, '/red|web/').filter(available)
-          expect(set.map(&:hostname)).to eq(%w{server1 server2 server3})
+          expect(set.map(&:hostname)).to eq(%w{server1 server2 server3 server5})
         end
         it 'returns hosts with combination of string role and regex' do
           set = Filter.new(:role, 'db,/red/').filter(available)

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

@@ -33,7 +33,7 @@ module Capistrano
       end
 
       describe 'comparing identity' do
-        subject { server.matches? Server[hostname] }
+        subject { server.hostname == Server[hostname].hostname }
 
         context 'with the same user, hostname and port' do
           let(:hostname) { 'root@hostname:1234' }
@@ -42,12 +42,12 @@ module Capistrano
 
         context 'with a different user' do
           let(:hostname) { 'deployer@hostname:1234' }
-          it { expect(subject).to be_falsey }
+          it { expect(subject).to be_truthy }
         end
 
         context 'with a different port' do
           let(:hostname) { 'root@hostname:5678' }
-          it { expect(subject).to be_falsey }
+          it { expect(subject).to be_truthy }
         end
 
         context 'with a different hostname' do
@@ -94,6 +94,10 @@ module Capistrano
           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'
+          end
         end
 
         context 'properties contains port' do
@@ -171,6 +175,18 @@ module Capistrano
             end
           end
 
+          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 }}
+              it { expect(subject).to be_falsey }
+            end
+          end
+
           context 'value does not match server properly' do
             context 'with :filter' do
               let(:options) { { filter: :inactive }}
@@ -189,6 +205,18 @@ module Capistrano
           end
         end
 
+        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 }}
+            it { expect(subject).to be_falsey }
+          end
+        end
+
         context 'value is a proc' do
           context 'value matches server property' do
 
@@ -261,6 +289,9 @@ module Capistrano
           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'
+          end
           it 'contains keys' do
             expect(server.netssh_options[:keys]).to eq %w(/home/another_user/.ssh/id_rsa)
           end

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

@@ -18,6 +18,12 @@ module Capistrano
           expect(servers.count).to eq 1
         end
 
+        it 'handles de-duplification within roles with users' do
+          servers.add_role(:app, %w{1}, user: 'nick')
+          servers.add_role(:app, %w{1}, user: 'fred')
+          expect(servers.count).to eq 1
+        end
+
         it 'accepts instances of server objects' do
           servers.add_role(:app, [Capistrano::Configuration::Server.new('example.net'), 'example.com'])
           expect(servers.roles_for([:app]).length).to eq 2
@@ -134,7 +140,23 @@ module Capistrano
           servers.add_host('1', roles: [:app, 'web'], test: :value, user: 'root', port: 34)
           servers.add_host('1', roles: [:app, 'web'], test: :value, user: 'deployer', port: 34)
           servers.add_host('1', roles: [:app, 'web'], test: :value, user: 'deployer', port: 56)
-          expect(servers.count).to eq(8)
+          expect(servers.count).to eq(1)
+        end
+
+        describe "with a :user property" do
+
+          it 'sets the server ssh username' do
+            servers.add_host('1', roles: [:app, 'web'], user: 'nick')
+            expect(servers.count).to eq(1)
+            expect(servers.roles_for([:all]).first.user).to eq 'nick'
+          end
+
+          it 'overwrites the value of a user specified in the hostname' do
+            servers.add_host('brian@1', roles: [:app, 'web'], user: 'nick')
+            expect(servers.count).to eq(1)
+            expect(servers.roles_for([:all]).first.user).to eq 'nick'
+          end
+
         end
 
         it 'overwrites the value of a previously defined scalar property' do
@@ -169,6 +191,20 @@ module Capistrano
           expect(servers.roles_for([:array_test]).first.properties.array_property).to eq [1,2]
         end
 
+        it 'updates roles when custom user defined' do
+          servers.add_host('1', roles: ['foo'], user: 'custom')
+          servers.add_host('1', roles: ['bar'], user: 'custom')
+          expect(servers.roles_for([:foo]).first.hostname).to eq '1'
+          expect(servers.roles_for([:bar]).first.hostname).to eq '1'
+        end
+
+        it 'updates roles when custom port defined' do
+          servers.add_host('1', roles: ['foo'], port: 1234)
+          servers.add_host('1', roles: ['bar'], port: 1234)
+          expect(servers.roles_for([:foo]).first.hostname).to eq '1'
+          expect(servers.roles_for([:bar]).first.hostname).to eq '1'
+        end
+
       end
 
       describe 'selecting roles' do

data/spec/lib/capistrano/configuration_spec.rb

@@ -180,6 +180,17 @@ module Capistrano
         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 do |ssh| ssh.ssh_options = { password: 'einstein' } end
+          config.configure_backend
+          expect(config.backend.config.backend.config.ssh_options).to eq({ user: 'albert', password: 'einstein' })
+        end
+      end
     end
   end
 end

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

@@ -1,69 +1,190 @@
 require 'spec_helper'
 
-module Capistrano
-  module DSL
+describe Capistrano::DSL::Paths do
 
-    class DummyPaths
-      include Paths
+  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} }
+
+  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')]
+    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
 
-    describe Paths do
-      let(:paths) { DummyPaths.new }
-      let(:parent) { Pathname.new('/var/shared') }
+    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
 
-      let(:linked_dirs) { %w{log public/system} }
-      let(:linked_files) { %w{config/database.yml log/my.log} }
+  describe '#linked_dir_parents' do
+    subject { paths.linked_dir_parents(parent) }
 
+    before do
+      paths.expects(:fetch).with(:linked_dirs).returns(linked_dirs)
+    end
 
-      describe '#linked_dirs' do
-        subject { paths.linked_dirs(parent) }
+    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
 
-        before do
-          paths.expects(:fetch).with(:linked_dirs).returns(linked_dirs)
-        end
+    subject { dsl.release_path }
 
-        it 'returns the full pathnames' do
-          expect(subject).to eq [Pathname.new('/var/shared/log'), Pathname.new('/var/shared/public/system')]
-        end
+    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
 
-      describe '#linked_files' do
-        subject { paths.linked_files(parent) }
+    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
 
-        before do
-          paths.expects(:fetch).with(:linked_files).returns(linked_files)
-        end
+  describe '#set_release_path' do
+    let(:now) { Time.parse("Oct 21 16:29:00 2015") }
+    subject { dsl.release_path }
 
-        it 'returns the full pathnames' do
-          expect(subject).to eq [Pathname.new('/var/shared/config/database.yml'), Pathname.new('/var/shared/log/my.log')]
-        end
+    context 'without a timestamp' do
+      before do
+        dsl.env.expects(:timestamp).returns(now)
+        dsl.set_release_path
       end
 
-      describe '#linked_file_dirs' do
-        subject { paths.linked_file_dirs(parent) }
+      it 'returns the release path with the current env timestamp' do
+        expect(subject.to_s).to eq '/var/www/releases/20151021162900'
+      end
+    end
 
-        before do
-          paths.expects(:fetch).with(:linked_files).returns(linked_files)
-        end
+    context 'with a timestamp' do
+      before do
+        dsl.set_release_path('timestamp')
+      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
+      it 'returns the release path with the timestamp' do
+        expect(subject.to_s).to eq '/var/www/releases/timestamp'
       end
+    end
+  end
 
-      describe '#linked_dir_parents' do
-        subject { paths.linked_dir_parents(parent) }
+  describe '#deploy_config_path' do
+    subject { dsl.deploy_config_path.to_s }
 
-        before do
-          paths.expects(:fetch).with(:linked_dirs).returns(linked_dirs)
-        end
+    context 'when not specified' do
+      before do
+        dsl.delete(:deploy_config_path)
+      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
+      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/support/Vagrantfile

@@ -1,13 +1,24 @@
-Vagrant::Config.run do |config|
+require 'open-uri'
+
+Vagrant.configure("2") do |config|
+
+  config.ssh.insert_key = false
 
   [:app].each_with_index do |role, i|
     config.vm.define(role, primary: true) do |config|
-      config.vm.box = role
-      config.vm.box = 'precise64'
-      config.vm.box_url = 'http://files.vagrantup.com/precise64.box'
-      config.vm.forward_port 22, "222#{i}".to_i
+      config.vm.define role
+      config.vm.box = 'hashicorp/precise64'
+      config.vm.network "forwarded_port", guest: 22, host: "222#{i}".to_i
       config.vm.provision :shell, inline: 'sudo apt-get -y install git-core'
+
+      vagrantkey = open("https://raw.githubusercontent.com/mitchellh/vagrant/master/keys/vagrant.pub", "r",&:read)
+
+      config.vm.provision :shell,
+        inline: <<-INLINE
+          install -d -m 700 /root/.ssh
+          echo -e "#{vagrantkey}" > /root/.ssh/authorized_keys
+          chmod 0600 /root/.ssh/authorized_keys
+      INLINE
     end
   end
-
 end