capistrano 3.2.1 → 3.3.3

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

@@ -28,6 +28,15 @@ module Capistrano
           expect(servers.roles_for([:app]).count).to eq 1
         end
 
+        it 'creates distinct server properties' do
+          servers.add_role(:db, %w{1 2}, db: { port: 1234 } )
+          servers.add_host('1', db: { master: true })
+          expect(servers.count).to eq(2)
+          expect(servers.roles_for([:db]).count).to eq 2
+          expect(servers.find(){|s| s.hostname == '1'}.properties.db).to eq({ port: 1234, master: true })
+          expect(servers.find(){|s| s.hostname == '2'}.properties.db).to eq({ port: 1234 })
+        end
+
       end
 
       describe 'adding a role to an existing server' do
@@ -59,15 +68,25 @@ module Capistrano
       end
 
       describe 'finding the primary server' do
+        after do
+          Configuration.reset!
+        end
         it 'takes the first server if none have the primary property' do
           servers.add_role(:app, %w{1 2})
-          servers.fetch_primary(:app).hostname.should == '1'
+          expect(servers.fetch_primary(:app).hostname).to eq('1')
         end
 
         it 'takes the first server with the primary have the primary flag' do
           servers.add_role(:app, %w{1 2})
           servers.add_host('2', primary: true)
-          servers.fetch_primary(:app).hostname.should == '2'
+          expect(servers.fetch_primary(:app).hostname).to eq('2')
+        end
+
+        it 'ignores any on_filters' do
+          Configuration.env.set :filter, { host: '1'}
+          servers.add_role(:app, %w{1 2})
+          servers.add_host('2', primary: true)
+          expect(servers.fetch_primary(:app).hostname).to eq('2')
         end
       end
 
@@ -115,8 +134,36 @@ 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)
-          servers.should have(8).items
+          expect(servers.count).to eq(8)
+        end
+
+        it 'overwrites the value of a previously defined scalar property' do
+          servers.add_host('1', roles: [:app, 'web'], test: :volatile)
+          expect(servers.count).to eq(1)
+          expect(servers.roles_for([:all]).first.properties.test).to eq :volatile
+        end
+
+        it 'merges previously defined hash properties' do
+          servers.add_host('1', roles: [:b], db: { port: 1234 })
+          servers.add_host('1', roles: [:b], db: { master: true })
+          expect(servers.count).to eq(1)
+          expect(servers.roles_for([:b]).first.properties.db).to eq({ port: 1234, master: true })
+        end
+
+        it 'concatenates previously defined array properties' do
+          servers.add_host('1', roles: [:b], steps: [1,3,5])
+          servers.add_host('1', roles: [:b], steps: [1,9])
+          expect(servers.count).to eq(1)
+          expect(servers.roles_for([:b]).first.properties.steps).to eq([1,3,5,1,9])
+        end
+
+        it 'merges previously defined set properties' do
+          servers.add_host('1', roles: [:b], endpoints: Set[123,333])
+          servers.add_host('1', roles: [:b], endpoints: Set[222,333])
+          expect(servers.count).to eq(1)
+          expect(servers.roles_for([:b]).first.properties.endpoints).to eq(Set[123,222,333])
         end
+
       end
 
       describe 'selecting roles' do
@@ -181,11 +228,9 @@ module Capistrano
 
       end
 
-      describe 'filtering roles' do
+      describe 'filtering roles internally' do
 
         before do
-          ENV.stubs(:[]).with('ROLES').returns('web,db')
-          ENV.stubs(:[]).with('HOSTS').returns(nil)
           servers.add_host('1', roles: :app, active: true)
           servers.add_host('2', roles: :app)
           servers.add_host('3', roles: :web)
@@ -195,31 +240,67 @@ module Capistrano
 
         subject { servers.roles_for(roles).map(&:hostname) }
 
-        context 'when selecting all roles' do
-          let(:roles) { [:all] }
+        context 'with the ROLES environment variable set' do
 
-          it 'returns the roles specified by ROLE' do
-            expect(subject).to eq %w{3 4 5}
+          before do
+            ENV.stubs(:[]).with('ROLES').returns('web,db')
+            ENV.stubs(:[]).with('HOSTS').returns(nil)
+          end
+
+          context 'when selecting all roles' do
+            let(:roles) { [:all] }
+            it 'ignores it' do
+              expect(subject).to eq %w{1 2 3 4 5}
+            end
           end
-        end
 
-        context 'when selecting roles included in ROLE' do
-          let(:roles) { [:app, :web] }
+          context 'when selecting specific roles' do
+            let(:roles) { [:app, :web] }
+            it 'ignores it' do
+              expect(subject).to eq %w{1 2 3 4}
+            end
+          end
 
-          it 'returns only roles that match ROLE' do
-            expect(subject).to eq %w{3 4}
+          context 'when selecting roles not included in ROLE' do
+            let(:roles) { [:app] }
+            it 'ignores it' do
+              expect(subject).to eq %w{1 2}
+            end
           end
+
         end
 
-        context 'when selecting roles not included in ROLE' do
-          let(:roles) { [:app] }
+        context 'with the HOSTS environment variable set' do
+
+          before do
+            ENV.stubs(:[]).with('ROLES').returns(nil)
+            ENV.stubs(:[]).with('HOSTS').returns('3,5')
+          end
 
-          it 'is empty' do
-            expect(subject).to be_empty
+          context 'when selecting all roles' do
+            let(:roles) { [:all] }
+            it 'ignores it' do
+              expect(subject).to eq %w{1 2 3 4 5}
+            end
           end
+
+          context 'when selecting specific roles' do
+            let(:roles) { [:app, :web] }
+            it 'ignores it' do
+              expect(subject).to eq %w{1 2 3 4}
+            end
+          end
+
+          context 'when selecting no roles' do
+            let(:roles) { [] }
+            it 'ignores it' do
+              expect(subject).to be_empty
+            end
+          end
+
         end
-      end
 
+      end
     end
   end
 end

data/spec/lib/capistrano/configuration_spec.rb

@@ -5,10 +5,17 @@ module Capistrano
     let(:config) { Configuration.new }
     let(:servers) { stub }
 
+    describe '.new' do
+      it 'accepts initial hash' do
+        configuration = described_class.new(custom: 'value')
+        expect(configuration.fetch(:custom)).to eq('value')
+      end
+    end
+
     describe '.env' do
       it 'is a global accessor to a single instance' do
         Configuration.env.set(:test, true)
-        expect(Configuration.env.fetch(:test)).to be_true
+        expect(Configuration.env.fetch(:test)).to be_truthy
       end
     end
 
@@ -48,6 +55,19 @@ module Capistrano
         end
       end
 
+      context 'set_if_empty' do
+        it 'sets the value when none is present' do
+          config.set_if_empty(:key, :value)
+          expect(subject).to eq :value
+        end
+
+        it 'does not overwrite the value' do
+          config.set(:key, :value)
+          config.set_if_empty(:key, :update)
+          expect(subject).to eq :value
+        end
+      end
+
       context 'value is not set' do
         it 'returns the default value' do
           expect(subject).to eq :default
@@ -138,14 +158,15 @@ module Capistrano
 
     describe 'asking' do
       let(:question) { stub }
+      let(:options) { Hash.new }
 
       before do
-        Configuration::Question.expects(:new).with(config, :branch, :default).
+        Configuration::Question.expects(:new).with(:branch, :default, options).
           returns(question)
       end
 
       it 'prompts for the value when fetching' do
-        config.ask(:branch, :default)
+        config.ask(:branch, :default, options)
         expect(config.fetch(:branch)).to eq question
       end
     end

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

@@ -0,0 +1,88 @@
+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' do
+        task_enhancements.after('task', 'after_task')
+        task_enhancements.before('task', 'before_task')
+
+        Rake::Task['task'].invoke order
+
+        expect(order).to eq(['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')
+
+        Rake::Task['task'].invoke order
+
+        expect(order).to eq(['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
+
+        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(['before_task', 'task', 'after_task'])
+      end
+
+    end
+
+    describe 'remote_file' do
+      subject(:remote_file) { task_enhancements.remote_file('source' => 'destination') }
+
+      it { expect(remote_file.name).to eq('source') }
+      it { is_expected.to be_a(Capistrano::UploadTask) }
+
+      describe 'namespaced' do
+        let(:app) { Rake.application }
+        around { |ex| app.in_namespace('namespace', &ex) }
+
+        it { expect(remote_file.name).to eq('source') }
+        it { is_expected.to be_a(Capistrano::UploadTask) }
+      end
+    end
+  end
+end

data/spec/lib/capistrano/dsl_spec.rb

@@ -27,14 +27,14 @@ module Capistrano
         before do
           dsl.set(:stage, :sandbox)
         end
-        it { should be_true }
+        it { expect(subject).to be_truthy }
       end
 
       context 'stage is not set' do
         before do
           dsl.set(:stage, nil)
         end
-        it { should be_false }
+        it { expect(subject).to be_falsey }
       end
     end
 
@@ -48,16 +48,5 @@ module Capistrano
         dsl.sudo(:my, :command)
       end
     end
-
-    describe '#local_user' do
-
-      before do
-        Etc.expects(:getlogin)
-      end
-
-      it 'delegates to Etc#getlogin' do
-        dsl.local_user
-      end
-    end
   end
 end

data/spec/lib/capistrano/git_spec.rb

@@ -31,7 +31,7 @@ module Capistrano
     describe "#check" do
       it "should test the repo url" do
         context.expects(:repo_url).returns(:url)
-        context.expects(:test).with(:git, :'ls-remote -h', :url).returns(true)
+        context.expects(:execute).with(:git, :'ls-remote -h', :url).returns(true)
 
         subject.check
       end
@@ -57,11 +57,22 @@ module Capistrano
     end
 
     describe "#release" do
-      it "should run git archive" do
-        context.expects(:fetch).returns(:branch)
+      it "should run git archive without a subtree" do
+        context.expects(:fetch).with(:repo_tree).returns(nil)
+        context.expects(:fetch).with(:branch).returns(:branch)
         context.expects(:release_path).returns(:path)
 
-        context.expects(:execute).with(:git, :archive, :branch, '| tar -x -C', :path)
+        context.expects(:execute).with(:git, :archive, :branch, '| tar -x -f - -C', :path)
+
+        subject.release
+      end
+
+      it "should run git archive with a subtree" do
+        context.expects(:fetch).with(:repo_tree).returns('tree')
+        context.expects(:fetch).with(:branch).returns(:branch)
+        context.expects(:release_path).returns(:path)
+
+        context.expects(:execute).with(:git, :archive, :branch, 'tree', '| tar -x --strip-components 1 -f - -C', :path)
 
         subject.release
       end

data/spec/lib/capistrano/hg_spec.rb

@@ -57,14 +57,25 @@ module Capistrano
     end
 
     describe "#release" do
-      it "should run hg archive" do
-        context.expects(:fetch).returns(:branch)
+      it "should run hg archive without a subtree" do
+        context.expects(:fetch).with(:repo_tree).returns(nil)
+        context.expects(:fetch).with(:branch).returns(:branch)
         context.expects(:release_path).returns(:path)
 
         context.expects(:execute).with(:hg, "archive", :path, "--rev", :branch)
 
         subject.release
       end
+
+      it "should run hg archive with a subtree" do
+        context.expects(:fetch).with(:repo_tree).returns('tree')
+        context.expects(:fetch).with(:branch).returns(:branch)
+        context.expects(:release_path).returns(:path)
+
+        context.expects(:execute).with(:hg, "archive --type tgz -p . -I", 'tree', "--rev", :branch, '| tar -x --strip-components 1 -f - -C', :path)
+
+        subject.release
+      end
     end
   end
 end

data/spec/lib/capistrano/scm_spec.rb

@@ -50,21 +50,21 @@ module Capistrano
       describe "#repo_url" do
         it "should return the repo url according to the context" do
           context.expects(:repo_url).returns(:url)
-          subject.repo_url.should == :url
+          expect(subject.repo_url).to eq(:url)
         end
       end
 
       describe "#repo_path" do
         it "should return the repo path according to the context" do
           context.expects(:repo_path).returns(:path)
-          subject.repo_path.should == :path
+          expect(subject.repo_path).to eq(:path)
         end
       end
 
       describe "#release_path" do
         it "should return the release path according to the context" do
           context.expects(:release_path).returns('/path/to/nowhere')
-          subject.release_path.should == '/path/to/nowhere'
+          expect(subject.release_path).to eq('/path/to/nowhere')
         end
       end
 

data/spec/lib/capistrano/svn_spec.rb

@@ -60,10 +60,20 @@ module Capistrano
       it "should run svn export" do        
         context.expects(:release_path).returns(:path)
         
-        context.expects(:execute).with(:svn, :export, '.', :path)
+        context.expects(:execute).with(:svn, :export, '--force', '.', :path)
 
         subject.release
       end
     end
+
+    describe "#fetch_revision" do
+      it "should run fetch revision" do
+        context.expects(:repo_path).returns(:path)
+
+        context.expects(:capture).with(:svnversion, :path)
+
+        subject.fetch_revision
+      end
+    end
   end
 end