rhc 1.6.8 → 1.7.8

data/spec/rest_spec_helper.rb

@@ -4,7 +4,7 @@ require 'rhc/rest/mock'
 require 'rhc/exceptions'
 require 'base64'
 
-Spec::Matchers.define :have_same_attributes_as do |expected|
+RSpec::Matchers.define :have_same_attributes_as do |expected|
   match do |actual|
     (actual.instance_variables == expected.instance_variables) &&
       (actual.instance_variables.map { |i| instance_variable_get(i) } ==
@@ -26,6 +26,6 @@ module RestSpecHelper
   include RHC::Rest::Mock
 end
 
-Spec::Runner.configure do |configuration|
+RSpec.configure do |configuration|
   include(RestSpecHelper)
 end

data/spec/rhc/cli_spec.rb

@@ -26,6 +26,20 @@ describe RHC::CLI do
     it('should provide a --config switch') { run_output.should =~ /\-\-config FILE/ }
   end
 
+  shared_examples_for 'a list of all commands' do
+    let(:arguments) { @arguments or raise "no arguments" }
+    it('should contain a message') { run_output.should =~ /Showing all commands/ }
+    it('should contain command help') { run_output.should =~ /Create an application./ }
+    it('should contain aliases') { run_output.should =~ /\(also/ }
+  end
+
+  shared_examples_for 'a list of commands' do
+    let(:arguments) { @arguments or raise "no arguments" }
+    it('should contain a message') { run_output.should =~ /Showing commands matching '/ }
+    it('should contain command help') { run_output.should =~ /Create an application./ }
+    it('should contain aliases') { run_output.should =~ /\(also/ }
+  end
+
   shared_examples_for 'a command-line options help page' do
     let(:arguments) { @arguments or raise "no arguments" }
     it('should contain an introduction') { run_output.should =~ /The following options can be passed to any/ }
@@ -92,6 +106,23 @@ describe RHC::CLI do
       it_should_behave_like 'an invalid command'
     end
 
+    context 'with help commands' do
+      before(:each) { @arguments = ['help', 'commands'] }
+      it_should_behave_like 'a list of all commands'
+    end
+
+    context 'with help and possible command matches' do
+      before(:each) { @arguments = ['help', 'app c'] }
+      it_should_behave_like 'a list of commands'
+    end
+
+    context 'with help and a single matching command segment' do
+      let(:arguments){ ['help', 'app creat'] }
+      it("prints the usage for the command"){ run_output.should match('Usage: rhc app-create <') }
+      it("prints part of the description for the command"){ run_output.should match('OpenShift runs the components of your') }
+      it("prints a local option"){ run_output.should match('--namespace NAME') }
+    end
+
     context 'with --help' do
       before(:each){ @arguments = ['--help'] }
       it_should_behave_like 'a global help page'
@@ -121,14 +152,14 @@ describe RHC::CLI do
   describe '#set_terminal' do
     before(:each) { mock_terminal }
     it('should update $terminal.wrap_at') do 
-      $stdin.should_receive(:tty?).twice.and_return(true)
+      $stdin.should_receive(:tty?).once.and_return(true)
       HighLine::SystemExtensions.should_receive(:terminal_size).and_return([5])
       expect { RHC::CLI.set_terminal }.to change($terminal, :wrap_at)
     end
-    it('should update $terminal.page_at') do 
-      $stdin.should_receive(:tty?).twice.and_return(true)
-      $stdout.should_receive(:tty?).twice.and_return(true)
-      expect { RHC::CLI.set_terminal }.to change($terminal, :page_at)
+    it('should not update $terminal.page_at') do 
+      $stdin.should_receive(:tty?).once.and_return(true)
+      $stdout.should_receive(:tty?).once.and_return(true)
+      expect { RHC::CLI.set_terminal }.to_not change($terminal, :page_at)
     end
   end
 

data/spec/rhc/command_spec.rb

@@ -8,7 +8,7 @@ describe RHC::Commands::Base do
   let!(:config){ base_config }
 
   before{ c = RHC::Commands.instance_variable_get(:@commands); @saved_commands = c && c.dup || nil }
-  after do 
+  after do
     (Kernel.send(:remove_const, subject) if subject.is_a?(Class)) rescue nil
     RHC::Commands.instance_variable_set(:@commands, @saved_commands)
   end
@@ -19,7 +19,7 @@ describe RHC::Commands::Base do
 
     context 'when the class is at the root' do
       subject do
-        Kernel.module_eval do 
+        Kernel.module_eval do
           class StaticRootClass < RHC::Commands::Base; def run; 1; end; end
         end
         StaticRootClass
@@ -27,8 +27,8 @@ describe RHC::Commands::Base do
       its(:object_name) { should == 'static-root-class' }
     end
     context 'when the class is nested in a module' do
-      subject do 
-        Kernel.module_eval do 
+      subject do
+        Kernel.module_eval do
           module Nested; class StaticRootClass < RHC::Commands::Base; def run; 1; end; end; end
         end
         Nested::StaticRootClass
@@ -72,8 +72,8 @@ describe RHC::Commands::Base do
     end
 
     context 'when statically defined' do
-      subject do 
-        Kernel.module_eval do 
+      subject do
+        Kernel.module_eval do
           module Nested
             class Static < RHC::Commands::Base
               suppress_wizard
@@ -90,8 +90,8 @@ describe RHC::Commands::Base do
     end
 
     context 'when a command calls exit' do
-      subject do 
-        Kernel.module_eval do 
+      subject do
+        Kernel.module_eval do
           class Failing < RHC::Commands::Base
             def run
               exit 2
@@ -122,93 +122,137 @@ describe RHC::Commands::Base do
             summary "Test command execute-list"
             def execute_list(args); 1; end
 
+            argument :arg1, "Test arg", ['--test'], :optional => true
+            argument :arg2, "Test arg list", ['--test2'], :arg_type => :list, :optional => true
+            argument :arg3, "Test arg list", ['--test3'], :arg_type => :list, :optional => true
+            summary "Test command execute-vararg"
+            def execute_vararg(arg1, arg2, arg3); 1; end
+
+            RHC::Helpers.global_option '--test-context', 'Test', :context => :context_var
+            def execute_implicit
+            end
+
+            argument :testarg, "Test arg", ["--testarg testarg"], :context => :context_var
+            summary "Test command execute"
+            def execute_context_arg(testarg); 1; end
+
             def raise_error
               raise StandardError.new("test exception")
             end
             def raise_exception
               raise Exception.new("test exception")
             end
+
+            protected
+              def context_var
+                "contextual"
+              end
           end
         end
         Static
       end
 
-      it("should register itself") { expect { subject }.to change(commands, :length).by(5) }
+      it("should register itself") { expect { subject }.to change(commands, :length).by(8) }
       it("should have an object name of the class") { subject.object_name.should == 'static' }
 
       context 'and when test is called' do
-        it { expects_running('static', 'test').should call(:test).on(instance).with(no_args) }
+        it { expects_running('static-test').should call(:test).on(instance).with(no_args) }
       end
 
       context 'and when execute is called with argument' do
-        it { expects_running('static', 'execute', 'simplearg').should call(:execute).on(instance).with('simplearg') }
+        it { expects_running('static-execute', 'simplearg').should call(:execute).on(instance).with('simplearg') }
       end
       context 'and when execute is called with argument switch' do
-        it { expects_running('static', 'execute', '--testarg', 'switcharg').should call(:execute).on(instance).with('switcharg') }
+        it { expects_running('static-execute', '--testarg', 'switcharg').should call(:execute).on(instance).with('switcharg') }
       end
       context 'and when execute is called with same argument and switch' do
-        it { expects_running('statis', 'execute', 'duparg', '--testarg', 'duparg2').should exit_with_code(1) }
+        it { expects_running('statis-execute', 'duparg', '--testarg', 'duparg2').should exit_with_code(1) }
       end
 
       context 'and when the provided option is ambiguous' do
-        it { expects_running('static', 'execute', '-t', '--trace').should raise_error(OptionParser::AmbiguousOption) }
+        it { expects_running('static-execute', '-t', '--trace').should raise_error(OptionParser::AmbiguousOption) }
       end
 
       context 'and when execute is called with too many arguments' do
-        it { expects_running('static', 'execute', 'arg1', 'arg2').should exit_with_code(1) }
+        it { expects_running('static-execute', 'arg1', 'arg2').should exit_with_code(1) }
       end
 
       context 'and when execute is called with a missing argument' do
-        it { expects_running('static', 'execute').should exit_with_code(1) }
+        it { expects_running('static-execute').should exit_with_code(1) }
       end
 
       context 'and when execute_list is called' do
-        it { expects_running('static', 'execute-list', '--trace').should call(:execute_list).on(instance).with([]) }
-        it { expects_running('static', 'execute-list', '1', '2', '3').should call(:execute_list).on(instance).with(['1', '2', '3']) }
-        it { expects_running('static', 'execute-list', '1', '2', '3').should call(:execute_list).on(instance).with(['1', '2', '3']) }
-        it('should make the option available') { command_for('static', 'execute-list', '1', '2', '3').send(:options).tests.should == ['1','2','3'] }
+        it { expects_running('static-execute-list', '--trace').should call(:execute_list).on(instance).with([]) }
+        it { expects_running('static-execute-list', '1', '2', '3').should call(:execute_list).on(instance).with(['1', '2', '3']) }
+        it { expects_running('static-execute-list', '1', '2', '3').should call(:execute_list).on(instance).with(['1', '2', '3']) }
+        it('should make the option available') { command_for('static-execute-list', '1', '2', '3').send(:options).tests.should == ['1','2','3'] }
+      end
+
+      context 'and when execute_vararg is called' do
+        it{ expects_running('static-execute-vararg').should call(:execute_vararg).on(instance).with(nil, nil, nil) }
+        it{ expects_running('static-execute-vararg', '1', '2', '3').should call(:execute_vararg).on(instance).with('1', ['2', '3'], []) }
+        it("handles a list separator"){ expects_running('static-execute-vararg', '1', '2', '--', '3').should call(:execute_vararg).on(instance).with('1', ['2'], ['3']) }
+        it{ command_for('static-execute-vararg', '1', '2', '--', '3').send(:options).test.should == '1' }
+        it{ command_for('static-execute-vararg', '1', '2', '--', '3').send(:options).test2.should == ['2'] }
+        it{ command_for('static-execute-vararg', '1', '2', '--', '3').send(:options).test3.should == ['3'] }
+      end
+      context 'and when execute is called with a contextual global option' do
+        it("calls the helper") { command_for('static', 'execute-implicit').send(:options).test_context.should == 'contextual' }
+      end
+
+      context 'and when execute-context-arg is called with a contextual argument' do
+        it("calls the helper") { command_for('static', 'execute-context-arg').send(:options).test_context.should == 'contextual' }
+        it("takes the argument") { command_for('static', 'execute-context-arg', 'arg1').send(:options).testarg.should == 'arg1' }
       end
 
       context 'and when an error is raised in a call' do
-        it { expects_running('static', 'raise-error').should raise_error(StandardError, "test exception") }
+        it { expects_running('static-raise-error').should raise_error(StandardError, "test exception") }
       end
 
       context 'and when an exception is raised in a call' do
-        it { expects_running('static', 'raise-exception').should raise_error(Exception, "test exception") }
+        it { expects_running('static-raise-exception').should raise_error(Exception, "test exception") }
       end
 
       context 'and when an exception is raised in a call with --trace option' do
-        it { expects_running('static', 'raise-exception', "--trace").should raise_error(Exception, "test exception") }
+        it { expects_running('static-raise-exception', "--trace").should raise_error(Exception, "test exception") }
       end
 
       context 'and when deprecated alias is called' do
-        it do
+        it("prints a warning") do
           expects_running('static', 'exe', "arg").should call(:execute).on(instance).with('arg')
-          stderr.should match("Warning: This command is deprecated. Please use 'rhc static execute' instead.")
+          stderr.should match("Warning: This command is deprecated. Please use 'rhc static-execute' instead.")
         end
       end
 
       context 'and when deprecated alias is called with DISABLE_DEPRECATED env var' do
         before { ENV['DISABLE_DEPRECATED'] = '1' }
         after { ENV['DISABLE_DEPRECATED'] = nil }
-        it { expects_running('static', 'exe', 'arg', '--trace').should raise_error(RHC::DeprecatedError) }
+        it("raises an error") { expects_running('static', 'exe', 'arg', '--trace').should raise_error(RHC::DeprecatedError) }
       end
     end
   end
 
   describe "rest_client" do
     let(:instance){ subject }
+    before{ RHC::Rest::Client.any_instance.stub(:api_version_negotiated).and_return(1.4) }
 
     context "when initializing the object" do
-      let(:auth){ mock }
-      let(:basic_auth){ mock }
-      before{ RHC::Auth::Basic.should_receive(:new).once.with{ |arg| arg.should == instance.send(:options) }.and_return(basic_auth) }
-      before{ RHC::Auth::Token.should_receive(:new).once.with{ |arg, arg2, arg3| [arg, arg2, arg3].should == [instance.send(:options), basic_auth, instance.send(:token_store)] }.and_return(auth) }
-
-      it "should create a new auth object" do
-        subject.should_receive(:client_from_options).with(:auth => auth)
-        subject.send(:rest_client)
+      let(:auth){ mock('auth') }
+      let(:basic_auth){ mock('basic_auth') }
+      before{ RHC::Auth::Basic.should_receive(:new).at_least(1).times.with{ |arg| arg.should == instance.send(:options) }.and_return(basic_auth) }
+      before{ RHC::Auth::Token.should_receive(:new).any_number_of_times.with{ |arg, arg2, arg3| [arg, arg2, arg3].should == [instance.send(:options), basic_auth, instance.send(:token_store)] }.and_return(auth) }
+
+      context "with no options" do
+        before{ subject.should_receive(:client_from_options).with(:auth => basic_auth) }
+        it("should create only a basic auth object"){ subject.send(:rest_client) }
+      end
+
+      context "with use_authorization_tokens" do
+        before{ subject.send(:options).use_authorization_tokens = true }
+        before{ subject.should_receive(:client_from_options).with(:auth => auth) }
+        it("should create a token auth object"){ subject.send(:rest_client) }
       end
+
       it { subject.send(:rest_client).should be_a(RHC::Rest::Client) }
       it { subject.send(:rest_client).should equal subject.send(:rest_client) }
     end
@@ -217,7 +261,7 @@ describe RHC::Commands::Base do
       subject{ Class.new(RHC::Commands::Base){ object_name :test; def run; 0; end } }
       let(:instance) { subject.new }
       let(:rest_client){ command_for(*arguments).send(:rest_client) }
-      let(:basic_auth){ rest_client.send(:auth).send(:auth) }
+      let(:basic_auth){ auth = rest_client.send(:auth); auth.is_a?(RHC::Auth::Basic) ? auth : auth.send(:auth) }
       let(:stored_token){ nil }
       before{ instance.send(:token_store).stub(:get).and_return(nil) unless stored_token }
 
@@ -257,10 +301,18 @@ describe RHC::Commands::Base do
         let(:username){ 'foo' }
         let(:stored_token){ 'a_token' }
         let(:arguments){ ['test', '-l', username, '--server', mock_uri] }
-        before{ instance.send(:token_store).should_receive(:get).with{ |user, server| user.should == username; server.should == instance.send(:openshift_server) }.and_return(stored_token) }
         before{ stub_api; stub_user(:token => stored_token) }
-        it("has token set") { command_for(*arguments).send(:options).token.should == stored_token }
-        it("calls the server") { rest_client.user }
+
+        context "when tokens are not allowed" do
+          it("calls the server") { rest_client.send(:auth).is_a? RHC::Auth::Basic }
+        end
+
+        context "when tokens are allowed" do
+          let!(:config){ base_config{ |c, d| d.add('use_authorization_tokens', 'true') } }
+          before{ instance.send(:token_store).should_receive(:get).with{ |user, server| user.should == username; server.should == instance.send(:openshift_server) }.and_return(stored_token) }
+          it("has token set") { command_for(*arguments).send(:token_for_user).should == stored_token }
+          it("calls the server") { rest_client.user }
+        end
       end
 
       context "with username and tokens enabled" do
@@ -268,9 +320,9 @@ describe RHC::Commands::Base do
         let(:username){ 'foo' }
         let(:auth_token){ stub(:token => 'a_token') }
         let(:arguments){ ['test', '-l', username, '--server', mock_uri] }
-        before{ instance.send(:token_store).should_receive(:get).with{ |user, server| user.should == username; server.should == instance.send(:openshift_server) }.twice.and_return(nil) }
+        before{ instance.send(:token_store).should_receive(:get).with{ |user, server| user.should == username; server.should == instance.send(:openshift_server) }.and_return(nil) }
         before{ stub_api(false, true); stub_api_request(:get, 'broker/rest/user', false).to_return{ |request| request.headers['Authorization'] =~ /Bearer/ ? simple_user(username) : {:status => 401} } }
-        it("should attempt to create a new token") do 
+        it("should attempt to create a new token") do
           rest_client.should_receive(:new_session).ordered.and_return(auth_token)
           rest_client.user
         end
@@ -280,9 +332,9 @@ describe RHC::Commands::Base do
         let!(:config){ base_config{ |c, d| d.add('use_authorization_tokens', 'true') } }
         let(:username){ 'foo' }
         let(:arguments){ ['test', '-l', username, '--server', mock_uri] }
-        before{ instance.send(:token_store).should_receive(:get).with{ |user, server| user.should == username; server.should == instance.send(:openshift_server) }.twice.and_return(nil) }
+        before{ instance.send(:token_store).should_receive(:get).with{ |user, server| user.should == username; server.should == instance.send(:openshift_server) }.and_return(nil) }
         before{ stub_api(false, false); stub_api_request(:get, 'broker/rest/user', false).to_return{ |request| request.headers['Authorization'] =~ /Basic/ ? simple_user(username) : {:status => 401} } }
-        it("should prompt for password") do 
+        it("should prompt for password") do
           basic_auth.should_receive(:ask).once.and_return('password')
           rest_client.user
         end

data/spec/rhc/commands/account_spec.rb

@@ -21,7 +21,7 @@ describe RHC::Commands::Account do
     it('should show the gear capabilities') { run_output.should =~ /Allowed Gear Sizes:\s*small/ }
     it('should show the consumed gears') { run_output.should =~ /Gears Used:\s*0/ }
     it('should show the maximum gears') { run_output.should =~ /Gears Allowed:\s*3/ }
-    it { expect { run }.should exit_with_code(0) }
+    it { expect { run }.to exit_with_code(0) }
 
     context 'with a free plan' do
       let(:user_plan_id){ 'free' }
@@ -38,78 +38,4 @@ describe RHC::Commands::Account do
       it('should show') { run_output.should =~ /Plan:\s*Other/ }
     end
   end
-
-  describe '#logout' do
-    let(:arguments) { ['account', 'logout'] }
-    let(:username) { 'foo' }
-    let(:password) { 'pass' }
-    let(:supports_auth) { false }
-    let(:server) { mock_uri }
-    let!(:token_store) { RHC::Auth::TokenStore.new(Dir.mktmpdir) }
-    before{ user_config }
-    before do
-      stub_api(mock_user_auth, supports_auth)
-      stub_user
-      RHC::Auth::TokenStore.should_receive(:new).at_least(1).and_return(token_store)
-    end
-
-    it("should clear the token cache"){ expect{ run }.should call(:clear).on(token_store) }
-    it("should exit with success"){ expect{ run }.should exit_with_code(0) }
-    it("should display a message"){ run_output.should match("All local sessions removed.") }
-
-    context "when --all is requested" do
-      let(:arguments) { ['account', 'logout', '--all'] }
-
-      context "if the server does not implement authorizations" do
-        it("should display a message"){ run_output.should match(/Deleting all authorizations associated with your account.*not supported/) }
-        it("should exit with success"){ expect{ run }.should exit_with_code(0) }
-      end
-
-      context "if the server implements authorizations" do
-        let(:supports_auth) { true }
-        before{ stub_delete_authorizations }
-
-        it("should display a message"){ run_output.should match(/Deleting all authorizations associated with your account.*done/) }
-        it("should exit with success"){ expect{ run }.should exit_with_code(0) }
-      end
-    end
-
-    context "when --token is provided" do
-      let(:arguments) { ['account', 'logout', '--token', 'foo'] }
-      def user_auth; { :token => 'foo' }; end
-
-      context "if the server does not implement authorizations" do
-        it("should display a message"){ run_output.should match(/Ending session on server.*not supported/) }
-        it("should exit with success"){ expect{ run }.should exit_with_code(0) }
-      end
-
-      context "if the server implements authorizations" do
-        let(:supports_auth) { true }
-
-        context "if the server returns successfully" do
-          before{ stub_delete_authorization('foo') }
-
-          it("should display a message"){ run_output.should match(/Ending session on server.*deleted/) }
-          it("should exit with success"){ expect{ run }.should exit_with_code(0) }
-          it("should clear the token cache"){ expect{ run }.should call(:clear).on(token_store) }
-        end
-
-        context "if the server rejects the token" do
-          before{ stub_request(:delete, mock_href('broker/rest/user/authorizations/foo', false)).to_return(:status => 401, :body => {}.to_json) }
-
-          it("should display a message"){ run_output.should match(/Ending session on server.*already closed/) }
-          it("should exit with success"){ expect{ run }.should exit_with_code(0) }
-          it("should clear the token cache"){ expect{ run }.should call(:clear).on(token_store) }
-        end
-
-        context "if the server returns an unexpected error" do
-          before{ stub_request(:delete, mock_href('broker/rest/user/authorizations/foo', false)).to_return(:status => 500, :body => {}.to_json) }
-
-          it("should display a message"){ run_output.should match(/Ending session on server.*The server did not respond/) }
-          it("should exit with success"){ expect{ run }.should exit_with_code(0) }
-          it("should clear the token cache"){ expect{ run }.should call(:clear).on(token_store) }
-        end
-      end
-    end
-  end
 end

data/spec/rhc/commands/alias_spec.rb

@@ -99,9 +99,9 @@ describe RHC::Commands::Alias do
 
     context 'help is run' do
       it "should display help" do
-        expect { run }.should exit_with_code(0)
+        expect { run }.to exit_with_code(0)
       end
-      it('should output usage') { run_output.should match("Usage: rhc alias <command> <application> <alias> [--namespace namespace]") }
+      it('should output usage') { run_output.should match("Usage: rhc alias <action>$") }
     end
   end
 
@@ -110,9 +110,9 @@ describe RHC::Commands::Alias do
 
     context 'help is run' do
       it "should display help" do
-        expect { run }.should exit_with_code(0)
+        expect { run }.to exit_with_code(0)
       end
-      it('should output usage') { run_output.should match("Usage: rhc alias add <application> <alias> [--namespace namespace]") }
+      it('should output usage') { run_output.should match("Usage: rhc alias-add <application> <alias> [--namespace NAME]") }
     end
   end
 
@@ -121,9 +121,9 @@ describe RHC::Commands::Alias do
 
     context 'help is run' do
       it "should display help" do
-        expect { run }.should exit_with_code(0)
+        expect { run }.to exit_with_code(0)
       end
-      it('should output usage') { run_output.should match("Usage: rhc alias remove <application> <alias> [--namespace namespace]") }
+      it('should output usage') { run_output.should match("Usage: rhc alias-remove <application> <alias> [--namespace NAME]") }
     end
   end
 
@@ -132,9 +132,9 @@ describe RHC::Commands::Alias do
 
     context 'help is run' do
       it "should display help" do
-        expect { run }.should exit_with_code(0)
+        expect { run }.to exit_with_code(0)
       end
-      it('should output usage') { run_output.should match("Usage: rhc alias update-cert <application> <alias> --certificate FILE --private-key FILE [--passphrase passphrase]") }
+      it('should output usage') { run_output.should match("Usage: rhc alias-update-cert <application> <alias> --certificate FILE --private-key FILE [--passphrase passphrase]") }
     end
   end
 
@@ -143,9 +143,9 @@ describe RHC::Commands::Alias do
 
     context 'help is run' do
       it "should display help" do
-        expect { run }.should exit_with_code(0)
+        expect { run }.to exit_with_code(0)
       end
-      it('should output usage') { run_output.should match("Usage: rhc alias delete-cert <application> <alias>") }
+      it('should output usage') { run_output.should match("Usage: rhc alias-delete-cert <application> <alias>") }
     end
   end
 
@@ -154,15 +154,15 @@ describe RHC::Commands::Alias do
 
     context 'help is run' do
       it "should display help" do
-        expect { run }.should exit_with_code(0)
+        expect { run }.to exit_with_code(0)
       end
-      it('should output usage') { run_output.should match("Usage: rhc alias list <application>") }
+      it('should output usage') { run_output.should match("Usage: rhc alias-list <application>") }
     end
   end
 
   describe 'add alias' do
     let(:arguments) { ['alias', 'add', 'mock_app_0', 'www.foo.bar' ] }
-    it { expect { run }.should exit_with_code(0) }
+    it { expect { run }.to exit_with_code(0) }
     it { run_output.should =~ /Alias 'www.foo.bar' has been added/m }
   end
 
@@ -172,7 +172,7 @@ describe RHC::Commands::Alias do
     end
     context 'remove alias successfully' do
       let(:arguments) { ['alias', 'remove', 'mock_app_0', 'www.foo.bar' ] }
-      it { expect { run }.should exit_with_code(0) }
+      it { expect { run }.to exit_with_code(0) }
       it { run_output.should =~ /Alias 'www.foo.bar' has been removed/m }
     end
     context 'remove alias with server api <= 1.3' do
@@ -180,7 +180,7 @@ describe RHC::Commands::Alias do
       before do 
         rest_client.stub(:api_version_negotiated).and_return(1.3)
       end
-      it { expect { run }.should exit_with_code(0) }
+      it { expect { run }.to exit_with_code(0) }
       it { run_output.should =~ /Alias 'www.foo.bar' has been removed/m }
     end
   end
@@ -193,28 +193,28 @@ describe RHC::Commands::Alias do
       let(:arguments) { ['alias', 'update-cert', 'mock_app_0', 'www.foo.bar', 
         '--certificate', File.expand_path('../../assets/cert.crt', __FILE__),
         '--private-key', File.expand_path('../../assets/cert_key_rsa', __FILE__) ] }
-      it { expect { run }.should exit_with_code(0) }
+      it { expect { run }.to exit_with_code(0) }
       it { run_output.should =~ /SSL certificate successfully added/m }
     end
     context 'cert file not found' do
       let(:arguments) { ['alias', 'update-cert', 'mock_app_0', 'www.foo.bar', 
         '--certificate', File.expand_path('../../assets/nothing.foo', __FILE__),
         '--private-key', File.expand_path('../../assets/cert_key_rsa', __FILE__) ] }
-      it { expect { run }.should exit_with_code(1) }
+      it { expect { run }.to exit_with_code(1) }
       it { run_output.should =~ /Certificate file not found/m }
     end
     context 'private key file not found' do
       let(:arguments) { ['alias', 'update-cert', 'mock_app_0', 'www.foo.bar', 
         '--certificate', File.expand_path('../../assets/cert.crt', __FILE__),
         '--private-key', File.expand_path('../../assets/nothing.foo', __FILE__) ] }
-      it { expect { run }.should exit_with_code(1) }
+      it { expect { run }.to exit_with_code(1) }
       it { run_output.should =~ /Private key file not found/m }
     end
     context 'not existing certificate alias' do
       let(:arguments) { ['alias', 'update-cert', 'mock_app_0', 'www.unicorns.com', 
         '--certificate', File.expand_path('../../assets/cert.crt', __FILE__),
         '--private-key', File.expand_path('../../assets/cert_key_rsa', __FILE__) ] }
-      it { expect { run }.should exit_with_code(156) }
+      it { expect { run }.to exit_with_code(156) }
       it { run_output.should =~ /Alias www.unicorns.com can't be found in application/m }
     end
     context 'fails if server does not support' do
@@ -224,21 +224,21 @@ describe RHC::Commands::Alias do
       before do 
         rest_client.stub(:api_version_negotiated).and_return(1.3)
       end
-      it { expect { run }.should exit_with_code(1) }
+      it { expect { run }.to exit_with_code(1) }
       it { run_output.should =~ /The server does not support SSL certificates for custom aliases/m }
     end
     context 'invalid certificate file (empty)' do
       let(:arguments) { ['alias', 'update-cert', 'mock_app_0', 'www.foo.bar', 
         '--certificate', File.expand_path('../../assets/empty.txt', __FILE__),
         '--private-key', File.expand_path('../../assets/cert_key_rsa', __FILE__) ] }
-      it { expect { run }.should exit_with_code(1) }
+      it { expect { run }.to exit_with_code(1) }
       it { run_output.should =~ /Invalid certificate file/m }
     end
     context 'invalid private key file (empty)' do
       let(:arguments) { ['alias', 'update-cert', 'mock_app_0', 'www.foo.bar', 
         '--certificate', File.expand_path('../../assets/cert.crt', __FILE__),
         '--private-key', File.expand_path('../../assets/empty.txt', __FILE__) ] }
-      it { expect { run }.should exit_with_code(1) }
+      it { expect { run }.to exit_with_code(1) }
       it { run_output.should =~ /Invalid private key file/m }
     end
   end
@@ -249,12 +249,12 @@ describe RHC::Commands::Alias do
     end
     context 'delete existing certificate' do
       let(:arguments) { ['alias', 'delete-cert', 'mock_app_0', 'www.foo.bar', '--confirm'] }
-      it { expect { run }.should exit_with_code(0) }
+      it { expect { run }.to exit_with_code(0) }
       it { run_output.should =~ /SSL certificate successfully deleted/m }
     end
     context 'delete not existing certificate' do
       let(:arguments) { ['alias', 'delete-cert', 'mock_app_0', 'www.unicorns.com', '--confirm'] }
-      it { expect { run }.should exit_with_code(156) }
+      it { expect { run }.to exit_with_code(156) }
       it { run_output.should =~ /Alias www.unicorns.com can't be found in application mock_app_0/m }
     end
     context 'fails if server does not support' do
@@ -262,7 +262,7 @@ describe RHC::Commands::Alias do
       before do 
         rest_client.stub(:api_version_negotiated).and_return(1.3)
       end
-      it { expect { run }.should exit_with_code(1) }
+      it { expect { run }.to exit_with_code(1) }
       it { run_output.should =~ /The server does not support SSL certificates for custom aliases/m }
     end
   end
@@ -273,14 +273,14 @@ describe RHC::Commands::Alias do
     end
     context 'list app with existing certificate' do
       let(:arguments) { ['alias', 'list', 'mock_app_0'] }
-      it { expect { run }.should exit_with_code(0) }
+      it { expect { run }.to exit_with_code(0) }
       it { run_output.should =~ /Has Certificate?/m }
       it { run_output.should =~ /Certificate Added/m }
       it { run_output.should =~ /www.foo.bar/m }
     end
     context 'list app without certificates' do
       let(:arguments) { ['alias', 'list', 'mock_app_1'] }
-      it { expect { run }.should exit_with_code(0) }
+      it { expect { run }.to exit_with_code(0) }
       it { run_output.should =~ /No aliases associated with the application mock_app_1/m }
     end
     context 'simple list is server does not support ssl certs' do
@@ -288,7 +288,7 @@ describe RHC::Commands::Alias do
       before do 
         rest_client.stub(:api_version_negotiated).and_return(1.3)
       end
-      it { expect { run }.should exit_with_code(0) }
+      it { expect { run }.to exit_with_code(0) }
       it { run_output.should =~ /no/m }
       it { run_output.should =~ /-/m }
       it { run_output.should =~ /www.foo.bar/m }