capistrano 3.0.0.pre2 → 3.0.0.pre3

data/spec/integration/installation_spec.rb

@@ -0,0 +1,76 @@
+require 'integration_spec_helper'
+
+describe 'cap install', slow: true do
+
+  context 'with defaults' do
+    before :all do
+      create_test_app
+      Dir.chdir(test_app_path) do
+        %x[bundle exec cap install]
+      end
+    end
+
+    describe 'installation' do
+
+      it 'creates config/deploy' do
+        path = test_app_path.join('config/deploy')
+        expect(Dir.exists?(path)).to be_true
+      end
+
+      it 'creates lib/capistrano/tasks' do
+        path = test_app_path.join('lib/capistrano/tasks')
+        expect(Dir.exists?(path)).to be_true
+      end
+
+      it 'creates the deploy file' do
+        file = test_app_path.join('config/deploy.rb')
+        expect(File.exists?(file)).to be_true
+      end
+
+      it 'creates the stage files' do
+        staging = test_app_path.join('config/deploy/staging.rb')
+        production = test_app_path.join('config/deploy/production.rb')
+        expect(File.exists?(staging)).to be_true
+        expect(File.exists?(production)).to be_true
+      end
+
+    end
+  end
+
+  context 'with STAGES' do
+    before :all do
+      create_test_app
+      Dir.chdir(test_app_path) do
+        %x[bundle exec cap install STAGES=qa,production]
+      end
+    end
+
+    describe 'installation' do
+
+      it 'creates config/deploy' do
+        path = test_app_path.join('config/deploy')
+        expect(Dir.exists?(path)).to be_true
+      end
+
+      it 'creates lib/capistrano/tasks' do
+        path = test_app_path.join('lib/capistrano/tasks')
+        expect(Dir.exists?(path)).to be_true
+      end
+
+      it 'creates the deploy file' do
+        file = test_app_path.join('config/deploy.rb')
+        expect(File.exists?(file)).to be_true
+      end
+
+      it 'creates the stage files specified, not the defaults' do
+        qa = test_app_path.join('config/deploy/qa.rb')
+        production = test_app_path.join('config/deploy/production.rb')
+        staging = test_app_path.join('config/deploy/staging.rb')
+        expect(File.exists?(qa)).to be_true
+        expect(File.exists?(production)).to be_true
+        expect(File.exists?(staging)).to be_false
+      end
+
+    end
+  end
+end

data/spec/integration_spec_helper.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+require 'support/test_app'
+require 'support/matchers'
+
+include TestApp
+
+

data/spec/lib/capistrano/application_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Capistrano::Application do
+
+  it "provides a --trace option which enables SSHKit/NetSSH trace output"
+
+  it "provides a --format option which enables the choice of output formatting"
+
+  it "identifies itself as cap and not rake" do
+    pending "Waiting for: https://github.com/jimweirich/rake/pull/204"
+    out, _ = capture_io do
+      flags '--help', '-h'
+    end
+    out.should match(/\bcap [ -f capfile ]\b/)
+  end
+
+  it "overrides the rake method, but still prints the rake version" do
+    out, _ = capture_io do
+      flags '--version', '-V'
+    end
+    out.should match(/\bCapistrano Version\b/)
+    out.should match(/\b#{Capistrano::VERSION}\b/)
+    out.should match(/\bRake Version\b/)
+    out.should match(/\b#{RAKEVERSION}\b/)
+  end
+
+  def flags(*sets)
+    sets.each do |set|
+      ARGV.clear
+      @exit = catch(:system_exit) { command_line(*set) }
+    end
+    yield(subject.options) if block_given?
+  end
+
+  def command_line(*options)
+    options.each { |opt| ARGV << opt }
+    def subject.exit(*args)
+      throw(:system_exit, :exit)
+    end
+    subject.instance_eval do
+      handle_options
+    end
+    subject.options
+  end
+
+  def capture_io
+    require 'stringio'
+
+    orig_stdout, orig_stderr         = $stdout, $stderr
+    captured_stdout, captured_stderr = StringIO.new, StringIO.new
+    $stdout, $stderr                 = captured_stdout, captured_stderr
+
+    yield
+
+    return captured_stdout.string, captured_stderr.string
+  ensure
+    $stdout = orig_stdout
+    $stderr = orig_stderr
+  end
+
+end

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

@@ -12,6 +12,14 @@ module Capistrano
         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) }
 
@@ -43,6 +51,89 @@ module Capistrano
         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
+
     end
   end
 end

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

@@ -6,11 +6,28 @@ module Capistrano
       let(:servers) { Servers.new }
 
       describe 'adding a role' do
-        subject { servers.add_role(:app, %w{1 2}) }
 
         it 'adds two new server instances' do
-          expect{subject}.to change{servers.count}.from(0).to(2)
+          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
@@ -22,6 +39,7 @@ module Capistrano
         it 'adds new roles to existing servers' do
           expect(servers.count).to eq 2
         end
+
       end
 
       describe 'collecting server roles' do
@@ -35,20 +53,21 @@ module Capistrano
         end
 
         it 'returns an array of the roles' do
-          expect(servers.fetch_roles([:app]).collect(&:roles)).to eq [app, web_app, web_app]
-          expect(servers.fetch_roles([:web]).collect(&:roles)).to eq [web_app, web_app, web]
+          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 for if none have the primary property' 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"
+          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"
+          servers.fetch_primary(:app).hostname.should == '2'
         end
       end
 
@@ -59,21 +78,70 @@ module Capistrano
         end
 
         it 'returns the correct app servers' do
-          expect(servers.fetch_roles([:app]).map(&:hostname)).to eq %w{1 2}
+          expect(servers.roles_for([:app]).map(&:hostname)).to eq %w{1 2}
         end
 
         it 'returns the correct web servers' do
-          expect(servers.fetch_roles([:web]).map(&:hostname)).to eq %w{2 3}
+          expect(servers.roles_for([:web]).map(&:hostname)).to eq %w{2 3}
         end
 
         it 'returns the correct app and web servers' do
-          expect(servers.fetch_roles([:app, :web]).map(&:hostname)).to eq %w{1 2 3}
+          expect(servers.roles_for([:app, :web]).map(&:hostname)).to eq %w{1 2 3}
         end
 
         it 'returns all servers' do
-          expect(servers.fetch_roles([:all]).map(&:hostname)).to eq %w{1 2 3}
+          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 '#roles' do
+
+        before do
+          servers.add_host('1', roles: :app, active: true)
+          servers.add_host('2', roles: :app)
+        end
+
+        it 'raises if the filter would remove all matching hosts' do
+          I18n.expects(:t)
+          expect { servers.roles_for([:app, select: :inactive]) }.to raise_error
+        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: lambda { |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: lambda { |h| h.properties.active }]).length).to eq 1
+        end
+
+        it 'raises if the regular proc filter would remove all matching hosts' do
+          I18n.expects(:t)
+          expect { servers.roles_for([:app, select: lambda { |h| h.properties.inactive }])}.to raise_error
+        end
+
+      end
     end
   end
 end

data/spec/lib/capistrano/configuration_spec.rb

@@ -18,7 +18,7 @@ module Capistrano
 
         before do
           Configuration::Servers.expects(:new).returns(servers)
-          servers.expects(:add_role).with(:app, %w{server1 server2})
+          servers.expects(:add_role).with(:app, %w{server1 server2}, {})
         end
 
         it 'adds the role' do
@@ -75,6 +75,16 @@ module Capistrano
         expect(config.fetch(:branch)).to eq question
       end
     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

@@ -5,79 +5,6 @@ module Capistrano
 
     describe Env do
 
-      let(:env) { Configuration.new }
-
-      describe '#role' do
-
-        it 'can add a role, with hosts' do
-          env.role(:app, %w{example.com})
-          env.roles_for(:app).first.hostname.should == "example.com"
-        end
-
-        it 'handles de-duplification within roles' do
-          env.role(:app, %w{example.com})
-          env.role(:app, %w{example.com})
-          env.roles_for(:app).length.should == 1
-        end
-
-        it 'accepts instances of server objects' do
-          pending
-          env.role(:app, [Capistrano::Configuration::Server.new('example.net'), 'example.com'])
-          env.roles_for(:app).length.should == 2
-        end
-
-        it 'accepts non-enumerable types' do
-          env.role(:app, 'example.com')
-          env.roles_for(:app).length.should == 1
-        end
-
-      end
-
-      describe '#server' do
-
-        it "can create a server with properties" do
-          env.server('example.com', roles: [:app, "web"], my: :value)
-          env.roles_for(:app).first.hostname.should == 'example.com'
-          env.roles_for(:web).first.hostname.should == 'example.com'
-          env.roles_for(:all).first.properties.my.should == :value
-        end
-
-      end
-
-      describe '#roles' do
-
-        before do
-          env.server('example.com', roles: :app, active: true)
-          env.server('example.org', roles: :app)
-        end
-
-        it 'raises if the filter would remove all matching hosts' do
-          pending
-          env.server('example.org', active: true)
-          lambda do
-            env.roles_for(:app, filter: lambda { |s| !s.properties.active })
-          end.should raise_error
-        end
-
-        it 'can filter hosts by properties on the host object using symbol as shorthand' do
-          env.roles_for(:app, filter: :active).length.should == 1
-        end
-
-        it 'can select hosts by properties on the host object using symbol as shorthand' do
-          env.roles_for(:app, select: :active).length.should == 1
-        end
-
-        it 'can filter hosts by properties on the host using a regular proc' do
-          env.roles_for(:app, filter: lambda { |h| h.properties.active } ).length.should == 1
-        end
-
-        it 'can select hosts by properties on the host using a regular proc' do
-          env.roles_for(:app, select: lambda { |h| h.properties.active } ).length.should == 1
-        end
-
-      end
-
     end
-
   end
 end