capistrano 2.1.0 → 3.0.0

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

@@ -0,0 +1,249 @@
+require 'spec_helper'
+
+module Capistrano
+  class Configuration
+    describe Server do
+      let(:server) { Server.new('hostname') }
+
+      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)
+        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)
+        end
+      end
+
+
+      describe 'checking roles' do
+        subject { server.has_role?(:test) }
+
+        before do
+          server.add_role(:test)
+        end
+
+        it 'adds the role' do
+          expect{subject}.to be_true
+        end
+      end
+
+      describe 'comparing identity' do
+        subject { server.matches? hostname }
+
+        context 'with the same hostname' do
+          let(:hostname) { 'hostname' }
+          it { should be_true }
+        end
+
+        context 'with the same hostname and a user' do
+          let(:hostname) { 'user@hostname' }
+          it { should be_true }
+        end
+
+        context 'with a different hostname' do
+          let(:hostname) { 'otherserver' }
+          it { should be_false }
+        end
+      end
+
+      describe 'identifying as primary' do
+        subject { server.primary }
+        context 'server is primary' do
+          before do
+            server.set(:primary, true)
+          end
+          it 'returns self' do
+            expect(subject).to eq server
+          end
+        end
+
+        context 'server is not primary' do
+          it 'is falesy' do
+            expect(subject).to be_false
+          end
+        end
+      end
+
+      describe 'assigning properties' do
+
+        before do
+          server.with(properties)
+        end
+
+        context 'properties contains roles' do
+          let(:properties) { {roles: [:clouds]} }
+
+          it 'adds the roles' do
+            expect(server.roles.first).to eq :clouds
+          end
+        end
+
+        context 'properties contains user' do
+          let(:properties) { {user: 'tomc'} }
+
+          it 'sets the user' do
+            expect(server.user).to eq 'tomc'
+          end
+        end
+
+        context 'properties contains port' do
+          let(:properties) { {port: 2222} }
+
+          it 'sets the port' do
+            expect(server.port).to eq 2222
+          end
+        end
+
+        context 'properties contains key' do
+          let(:properties) { {key: '/key'} }
+
+          it 'adds the key' do
+            expect(server.keys).to include '/key'
+          end
+        end
+
+        context 'properties contains password' do
+          let(:properties) { {password: 'supersecret'} }
+
+          it 'adds the key' do
+            expect(server.password).to eq 'supersecret'
+          end
+        end
+
+        context 'new properties' do
+          let(:properties) { { webscales: 5 } }
+
+          it 'adds the properties' do
+            expect(server.properties.webscales).to eq 5
+          end
+        end
+
+        context 'existing properties' do
+          let(:properties) { { webscales: 6 } }
+
+          it 'keeps the existing properties' do
+            expect(server.properties.webscales).to eq 6
+            server.properties.webscales = 5
+            expect(server.properties.webscales).to eq 5
+          end
+        end
+      end
+
+      describe '#include?' do
+        let(:options) { {} }
+
+        subject { server.select?(options) }
+
+        before do
+          server.properties.active = true
+        end
+
+        context 'options are empty' do
+          it { should be_true }
+        end
+
+        context 'value is a symbol' do
+          context 'value matches server property' do
+
+            context 'with :filter' do
+              let(:options) { { filter: :active }}
+              it { should be_true }
+            end
+
+            context 'with :select' do
+              let(:options) { { select: :active }}
+              it { should be_true }
+            end
+          end
+
+          context 'value does not match server properly' do
+            context 'with :filter' do
+              let(:options) { { filter: :inactive }}
+              it { should be_false }
+            end
+
+            context 'with :select' do
+              let(:options) { { select: :inactive }}
+              it { should be_false }
+            end
+          end
+        end
+
+        context 'value is a proc' do
+          context 'value matches server property' do
+
+            context 'with :filter' do
+              let(:options) { { filter: ->(s) { s.properties.active } } }
+              it { should be_true }
+            end
+
+            context 'with :select' do
+              let(:options) { { select: ->(s) { s.properties.active } } }
+              it { should be_true }
+            end
+          end
+
+          context 'value does not match server properly' do
+            context 'with :filter' do
+              let(:options) { { filter: ->(s) { s.properties.inactive } } }
+              it { should be_false }
+            end
+
+            context 'with :select' do
+              let(:options) { { select: ->(s) { s.properties.inactive } } }
+              it { should be_false }
+            end
+          end
+        end
+
+      end
+
+      describe 'assign ssh_options' do
+        let(:server) { Server.new('user_name@hostname') }
+
+        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'
+          end
+        end
+
+        context 'custom' do
+          let(:properties) do
+            { ssh_options: {
+              user: 'another_user',
+              keys: %w(/home/another_user/.ssh/id_rsa),
+              forward_agent: false,
+              auth_methods: %w(publickey password) } }
+          end
+
+          before do
+            server.with(properties)
+          end
+
+          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'
+          end
+          it 'contains keys' do
+            expect(server.netssh_options[:keys]).to eq %w(/home/another_user/.ssh/id_rsa)
+          end
+          it 'contains auth_methods' do
+            expect(server.netssh_options[:auth_methods]).to eq %w(publickey password)
+          end
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,140 @@
+require 'spec_helper'
+
+module Capistrano
+  class Configuration
+    class Servers
+
+      describe RoleFilter do
+        let(:role_filter) { RoleFilter.new(required, available) }
+        let(:required) { [] }
+        let(:available) { [:web, :app, :db] }
+
+        describe '#new' do
+          it 'takes two arrays of role names' do
+            expect(role_filter)
+          end
+        end
+
+        describe '.for' do
+
+          subject { RoleFilter.for(required, available) }
+
+          context 'without env vars' do
+            context ':all required' do
+              let(:required) { [:all] }
+
+              it 'returns all available names' do
+                expect(subject).to eq available
+              end
+            end
+
+            context 'role names required' do
+              let(:required) { [:web, :app] }
+              it 'returns all required names' do
+                expect(subject).to eq required
+              end
+            end
+          end
+
+          context 'with ENV vars' do
+            before do
+              ENV.stubs(:[]).with('ROLES').returns('app,web')
+            end
+
+            context ':all required' do
+              let(:required) { [:all] }
+
+              it 'returns available names defined in ROLES' do
+                expect(subject).to eq [:app, :web]
+              end
+            end
+
+            context 'role names required' do
+              let(:required) { [:web, :db] }
+              it 'returns all required names defined in ROLES' do
+                expect(subject).to eq [:web]
+              end
+            end
+          end
+
+          context 'with configuration filters' do
+            before do
+              Configuration.env.set(:filter, roles: %w{app web})
+            end
+
+            context ':all required' do
+              let(:required) { [:all] }
+
+              it 'returns available names defined in the filter' do
+                expect(subject).to eq [:app, :web]
+              end
+            end
+
+            context 'role names required' do
+              let(:required) { [:web, :db] }
+              it 'returns all required names defined in the filter' do
+                expect(subject).to eq [:web]
+              end
+            end
+
+            after do
+              Configuration.env.delete(:filter)
+            end
+          end
+
+          context 'with a single configuration filter' do
+            before do
+              Configuration.env.set(:filter, roles: 'web')
+            end
+
+            context ':all required' do
+              let(:required) { [:all] }
+
+              it 'returns available names defined in the filter' do
+                expect(subject).to eq [:web]
+              end
+            end
+
+            context 'role names required' do
+              let(:required) { [:web, :db] }
+              it 'returns all required names defined in the filter' do
+                expect(subject).to eq [:web]
+              end
+            end
+
+            after do
+              Configuration.env.delete(:filter)
+            end
+          end
+
+          context 'with configuration filters and ENV vars' do
+            before do
+              Configuration.env.set(:filter, roles: %w{app})
+              ENV.stubs(:[]).with('ROLES').returns('web')
+            end
+
+            context ':all required' do
+              let(:required) { [:all] }
+
+              it 'returns available names defined in the filter' do
+                expect(subject).to eq [:web, :app]
+              end
+            end
+
+            context 'role names required' do
+              let(:required) { [:web, :db] }
+              it 'returns all required names defined in the filter' do
+                expect(subject).to eq [:web]
+              end
+            end
+
+            after do
+              Configuration.env.delete(:filter)
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,184 @@
+require 'spec_helper'
+
+module Capistrano
+  class Configuration
+    describe Servers do
+      let(:servers) { Servers.new }
+
+      describe 'adding a role' do
+
+        it 'adds two new server instances' do
+          expect{servers.add_role(:app, %w{1 2})}.
+            to change{servers.count}.from(0).to(2)
+        end
+
+        it 'handles de-duplification within roles' do
+          servers.add_role(:app, %w{1})
+          servers.add_role(:app, %w{1})
+          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
+        end
+
+        it 'accepts non-enumerable types' do
+          servers.add_role(:app, '1')
+          expect(servers.roles_for([:app]).count).to eq 1
+        end
+
+      end
+
+      describe 'adding a role to an existing server' do
+        before do
+          servers.add_role(:web, %w{1 2})
+          servers.add_role(:app, %w{1 2})
+        end
+
+        it 'adds new roles to existing servers' do
+          expect(servers.count).to eq 2
+        end
+
+      end
+
+      describe 'collecting server roles' do
+        let(:app) { Set.new([:app]) }
+        let(:web_app) { Set.new([:web, :app]) }
+        let(:web) { Set.new([:web]) }
+
+        before do
+          servers.add_role(:app, %w{1 2 3})
+          servers.add_role(:web, %w{2 3 4})
+        end
+
+        it 'returns an array of the roles' do
+          expect(servers.roles_for([:app]).collect(&:roles)).to eq [app, web_app, web_app]
+          expect(servers.roles_for([:web]).collect(&:roles)).to eq [web_app, web_app, web]
+        end
+      end
+
+      describe 'finding the primary server' do
+        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'
+        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'
+        end
+      end
+
+      describe 'fetching servers' do
+        before do
+          servers.add_role(:app, %w{1 2})
+          servers.add_role(:web, %w{2 3})
+        end
+
+        it 'returns the correct app servers' do
+          expect(servers.roles_for([:app]).map(&:hostname)).to eq %w{1 2}
+        end
+
+        it 'returns the correct web servers' do
+          expect(servers.roles_for([:web]).map(&:hostname)).to eq %w{2 3}
+        end
+
+        it 'returns the correct app and web servers' do
+          expect(servers.roles_for([:app, :web]).map(&:hostname)).to eq %w{1 2 3}
+        end
+
+        it 'returns all servers' do
+          expect(servers.roles_for([:all]).map(&:hostname)).to eq %w{1 2 3}
+        end
+      end
+
+      describe 'adding a server' do
+
+        before do
+          servers.add_host('1', roles: [:app, 'web'], test: :value)
+        end
+
+        it 'can create a server with properties' do
+          expect(servers.roles_for([:app]).first.hostname).to eq '1'
+          expect(servers.roles_for([:web]).first.hostname).to eq '1'
+          expect(servers.roles_for([:all]).first.properties.test).to eq :value
+        end
+
+      end
+
+      describe 'selecting roles' do
+
+        before do
+          servers.add_host('1', roles: :app, active: true)
+          servers.add_host('2', roles: :app)
+        end
+
+        it 'is empty if the filter would remove all matching hosts' do
+          expect(servers.roles_for([:app, select: :inactive])).to be_empty
+        end
+
+        it 'can filter hosts by properties on the host object using symbol as shorthand' do
+          expect(servers.roles_for([:app, filter: :active]).length).to eq 1
+        end
+
+        it 'can select hosts by properties on the host object using symbol as shorthand' do
+          expect(servers.roles_for([:app, select: :active]).length).to eq 1
+        end
+
+        it 'can filter hosts by properties on the host using a regular proc' do
+          expect(servers.roles_for([:app, filter: ->(h) { h.properties.active }]).length).to eq 1
+        end
+
+        it 'can select hosts by properties on the host using a regular proc' do
+          expect(servers.roles_for([:app, select: ->(h) { h.properties.active }]).length).to eq 1
+        end
+
+        it 'is empty if the regular proc filter would remove all matching hosts' do
+          expect(servers.roles_for([:app, select: ->(h) { h.properties.inactive }])).to be_empty
+        end
+
+      end
+
+      describe 'filtering roles' do
+
+        before do
+          ENV.stubs(:[]).with('ROLES').returns('web,db')
+          servers.add_host('1', roles: :app, active: true)
+          servers.add_host('2', roles: :app)
+          servers.add_host('3', roles: :web)
+          servers.add_host('4', roles: :web)
+          servers.add_host('5', roles: :db)
+        end
+
+        subject { servers.roles_for(roles).map(&:hostname) }
+
+        context 'when selecting all roles' do
+          let(:roles) { [:all] }
+
+          it 'returns the roles specified by ROLE' do
+            expect(subject).to eq %w{3 4 5}
+          end
+        end
+
+        context 'when selecting roles included in ROLE' do
+          let(:roles) { [:app, :web] }
+
+          it 'returns only roles that match ROLE' do
+            expect(subject).to eq %w{3 4}
+          end
+        end
+
+        context 'when selecting roles not included in ROLE' do
+          let(:roles) { [:app] }
+
+          it 'is empty' do
+            expect(subject).to be_empty
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/lib/capistrano/configuration_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+module Capistrano
+  describe Configuration do
+    let(:config) { Configuration.new }
+    let(:servers) { stub }
+
+    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
+      end
+    end
+
+    describe 'roles' do
+      context 'adding a role' do
+        subject { config.role(:app, %w{server1 server2}) }
+
+        before do
+          Configuration::Servers.expects(:new).returns(servers)
+          servers.expects(:add_role).with(:app, %w{server1 server2}, {})
+        end
+
+        it 'adds the role' do
+          expect(subject)
+        end
+      end
+    end
+
+    describe 'setting and fetching' do
+      subject { config.fetch(:key, :default) }
+
+      context 'value is set' do
+        before do
+          config.set(:key, :value)
+        end
+
+        it 'returns the set value' do
+          expect(subject).to eq :value
+        end
+      end
+
+      context 'value is not set' do
+        it 'returns the default value' do
+          expect(subject).to eq :default
+        end
+      end
+
+      context 'value is a proc' do
+        subject { config.fetch(:key, Proc.new { :proc } ) }
+        it 'calls the proc' do
+          expect(subject).to eq :proc
+        end
+      end
+
+      context 'block is passed to fetch' do
+        subject { config.fetch(:key, :default) { fail 'we need this!' } }
+
+        it 'returns the block value' do
+          expect { subject }.to raise_error
+        end
+      end
+    end
+
+    describe 'deleting' do
+      before do
+        config.set(:key, :value)
+      end
+
+      it 'deletes the value' do
+        config.delete(:key)
+        expect(config.fetch(:key)).to be_nil
+      end
+    end
+
+    describe 'asking' do
+      let(:question) { stub }
+
+      before do
+        Configuration::Question.expects(:new).with(config, :branch, :default).
+          returns(question)
+      end
+
+      it 'prompts for the value when fetching' do
+        config.ask(:branch, :default)
+        expect(config.fetch(:branch)).to eq question
+      end
+    end
+
+    describe 'setting the backend' do
+      it 'by default, is SSHKit' do
+        expect(config.backend).to eq SSHKit
+      end
+
+      it 'can be set to another class' do
+        config.backend = :test
+        expect(config.backend).to eq :test
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+module Capistrano
+  module DSL
+
+    describe Env do
+
+    end
+  end
+end