rhc 1.11.4 → 1.12.4

data/spec/rhc/command_spec.rb

@@ -56,10 +56,10 @@ describe RHC::Commands::Base do
       it("should run with wizard") do
         FakeFS do
           wizard_run = false
-          RHC::Wizard.stub!(:new) do |config|
+          RHC::Wizard.stub(:new) do |config|
             RHC::Wizard.unstub!(:new)
             w = RHC::Wizard.new(config)
-            w.stub!(:run) { wizard_run = true }
+            w.stub(:run) { wizard_run = true }
             w
           end
 
@@ -238,10 +238,10 @@ describe RHC::Commands::Base do
     before{ RHC::Rest::Client.any_instance.stub(:api_version_negotiated).and_return(1.4) }
 
     context "when initializing the object" do
-      let(:auth){ mock('auth') }
-      let(:basic_auth){ mock('basic_auth') }
+      let(:auth){ double('auth') }
+      let(:basic_auth){ double('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) }
+      before{ RHC::Auth::Token.stub(:new).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) }
@@ -275,7 +275,7 @@ describe RHC::Commands::Base do
         let(:username){ 'foo' }
         let(:password){ 'bar' }
         let(:arguments){ ['test', '-l', username, '--server', mock_uri] }
-        before{ stub_api(:user => username); stub_user(:user => username, :password => password) }
+        before{ stub_api; challenge{ stub_user(:user => username, :password => password) } }
         before{ basic_auth.should_receive(:ask).and_return(password) }
         it("asks for password") { rest_client.user }
       end
@@ -284,7 +284,7 @@ describe RHC::Commands::Base do
         let(:username){ 'foo' }
         let(:password){ 'bar' }
         let(:arguments){ ['test', '--server', mock_uri] }
-        before{ stub_api; stub_user(:user => username, :password => password) }
+        before{ stub_api; challenge{ stub_user(:user => username, :password => password) } }
         before{ basic_auth.should_receive(:ask).ordered.and_return(username) }
         before{ basic_auth.should_receive(:ask).ordered.and_return(password) }
         it("asks for password") { rest_client.user }
@@ -320,7 +320,7 @@ describe RHC::Commands::Base do
       context "with username and tokens enabled" do
         let!(:config){ base_config{ |c, d| d.add('use_authorization_tokens', 'true') } }
         let(:username){ 'foo' }
-        let(:auth_token){ stub(:token => 'a_token') }
+        let(:auth_token){ double(: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(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} } }
@@ -335,7 +335,11 @@ describe RHC::Commands::Base do
         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) }.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} } }
+        before do 
+          stub_api(false, false)
+          stub_api_request(:get, 'broker/rest/user', false).to_return{ |request| request.headers['Authorization'] =~ /Basic/ ? simple_user(username) : {:status => 401, :headers => {'WWW-Authenticate' => 'Basic realm="openshift broker"'} } }
+          stub_api_request(:get, 'broker/rest/user', {:user => username, :password => 'password'}).to_return{ simple_user(username) }
+        end
         it("should prompt for password") do
           basic_auth.should_receive(:ask).once.and_return('password')
           rest_client.user

data/spec/rhc/commands/account_spec.rb

@@ -12,8 +12,8 @@ describe RHC::Commands::Account do
     let(:server) { mock_uri }
     before{ user_config }
     before do
-      stub_api(true)
-      stub_user
+      stub_api
+      challenge{ stub_user }
     end
 
     it('should display the correct user') { run_output.should =~ /Login:\s*#{username}/ }

data/spec/rhc/commands/app_spec.rb

@@ -55,8 +55,8 @@ describe RHC::Commands::App do
   end
 
   describe '#check_domain!' do
-    let(:rest_client){ stub('RestClient') }
-    let(:domain){ stub('Domain', :id => 'test') }
+    let(:rest_client){ double('RestClient') }
+    let(:domain){ double('Domain', :id => 'test') }
     before{ subject.stub(:rest_client).and_return(rest_client) }
     let(:interactive){ false }
     before{ subject.stub(:interactive?).and_return(interactive) }
@@ -83,7 +83,7 @@ describe RHC::Commands::App do
     context "when interactive and no domains" do
       let(:interactive){ true }
       before{ rest_client.should_receive(:domains).twice.and_return([]) }
-      before{ RHC::DomainWizard.should_receive(:new).and_return(stub(:run => true)) }
+      before{ RHC::DomainWizard.should_receive(:new).and_return(double(:run => true)) }
       it("should raise if the wizard doesn't set the option"){ expect{ subject.send(:check_domain!) }.to raise_error(RHC::Rest::DomainNotFoundException) }
       after{ subject.send(:options).namespace.should be_nil }
     end
@@ -115,7 +115,7 @@ describe RHC::Commands::App do
 
     context "when dealing with config" do
       subject{ described_class.new(Commander::Command::Options.new(options)) }
-      let(:wizard){ s = stub('Wizard'); RHC::EmbeddedWizard.should_receive(:new).and_return(s); s }
+      let(:wizard){ s = double('Wizard'); RHC::EmbeddedWizard.should_receive(:new).and_return(s); s }
       let(:options){ nil }
       let(:interactive){ true }
       before{ subject.should_receive(:interactive?).at_least(1).times.and_return(interactive) }
@@ -142,7 +142,7 @@ describe RHC::Commands::App do
 
     context "when dealing with ssh keys" do
       subject{ described_class.new(options) }
-      let(:wizard){ s = stub('Wizard'); RHC::SSHWizard.should_receive(:new).and_return(s); s }
+      let(:wizard){ s = double('Wizard'); RHC::SSHWizard.should_receive(:new).and_return(s); s }
       let(:options){ Commander::Command::Options.new(:server => 'foo.com', :rhlogin => 'test') }
       let(:interactive){ true }
       before{ subject.should_receive(:interactive?).at_least(1).times.and_return(interactive) }
@@ -300,7 +300,7 @@ describe RHC::Commands::App do
       before(:each) do
         domain = rest_client.add_domain("mockdomain")
       end
-      it { expect { run }.to_not raise_error(ArgumentError, /The --no-dns option can't be used in conjunction with --enable-jenkins/) }
+      it { expect { run }.to_not raise_error }
     end
   end
 
@@ -504,8 +504,8 @@ describe RHC::Commands::App do
       let(:server){ mock_uri }
       let(:arguments){ ['delete-app', 'foo', '--confirm', '--trace'] }
       before do 
-        stub_api(true)
-        stub_one_domain('test')
+        stub_api
+        challenge{ stub_one_domain('test') }
         stub_one_application('test', 'foo')
       end
       before do 
@@ -703,7 +703,7 @@ describe RHC::Commands::App do
   describe "#create_app" do
     it("should list cartridges when a server error happens") do
       subject.should_receive(:list_cartridges)
-      domain = stub
+      domain = double
       domain.stub(:add_application).and_raise(RHC::Rest::ValidationException.new('Foo', :cartridges, 109))
       expect{ subject.send(:create_app, 'name', 'jenkins-1.4', domain) }.to raise_error(RHC::Rest::ValidationException)
     end

data/spec/rhc/commands/authorization_spec.rb

@@ -10,14 +10,14 @@ describe RHC::Commands::Authorization do
     let(:password) { 'pass' }
     let(:server) { mock_uri }
     before{ user_config }
-    before{ stub_api(true, true) }
+    before{ stub_api(false, true) }
   end
   def self.without_authorization
     let(:username) { 'foo' }
     let(:password) { 'pass' }
     let(:server) { mock_uri }
     before{ user_config }
-    before{ stub_api(true, false) }
+    before{ stub_api(false, false) }
   end
   def self.expect_an_unsupported_message
     context "without authorizations" do
@@ -31,7 +31,7 @@ describe RHC::Commands::Authorization do
     let(:arguments) { ['authorization'] }
     context "with authorizations" do
       with_authorization
-      before{ stub_authorizations }
+      before{ challenge{ stub_authorizations } }
       it('should display the note')           { run_output.should =~ /an_authorization/ }
       it('should display the token')          { run_output.should =~ /Token:\s+a_token_value/ }
       it('should display the expiration')     { run_output.should =~ /Expires In:\s+1 minute/ }
@@ -46,8 +46,8 @@ describe RHC::Commands::Authorization do
   describe '#run' do
     let(:arguments) { ['authorization', '--h']}
     context 'given --h' do
-      it 'should not raise SystemStackError' do
-        expect{ run }.to_not raise_error(SystemStackError)
+      it 'should not raise' do
+        expect{ run }.to_not raise_error
       end
     end
   end
@@ -56,7 +56,7 @@ describe RHC::Commands::Authorization do
     let(:arguments) { ['authorization', 'list'] }
     context "with authorizations" do
       with_authorization
-      before{ stub_authorizations }
+      before{ challenge{ stub_authorizations } }
       it('should display the note')           { run_output.should =~ /an_authorization/ }
       it('should display the token')          { run_output.should =~ /Token:\s+a_token_value/ }
       it('should display the expiration')     { run_output.should =~ /Expires In:\s+1 minute/ }
@@ -73,8 +73,8 @@ describe RHC::Commands::Authorization do
 
     context "with authorizations" do
       with_authorization
-      before{ stub_delete_authorization('foo') }
-      before{ stub_delete_authorization('bar') }
+      before{ challenge{ stub_delete_authorization('foo') } }
+      before{ challenge{ stub_delete_authorization('bar') } }
       it('should display success') { run_output.should =~ /Deleting auth.*done/ }
       it{ expect{ run }.to exit_with_code(0) }
       after{ a_request(:delete, mock_href('broker/rest/user/authorizations/foo', true)).should have_been_made }
@@ -95,7 +95,7 @@ describe RHC::Commands::Authorization do
 
     context "with authorizations" do
       with_authorization
-      before{ stub_delete_authorizations }
+      before{ challenge{ stub_delete_authorizations } }
       it('should display success') { run_output.should =~ /Deleting all auth.*done/ }
       it{ expect{ run }.to exit_with_code(0) }
       after{ a_request(:delete, mock_href('broker/rest/user/authorizations', true)).should have_been_made }
@@ -105,7 +105,7 @@ describe RHC::Commands::Authorization do
   end
 
   describe "#scope_help" do
-    let(:rest_client){ stub(:authorization_scope_list => [['scope_1', 'A description'], ['scope_2', 'Another description']]) }
+    let(:rest_client){ double(:authorization_scope_list => [['scope_1', 'A description'], ['scope_2', 'Another description']]) }
     before{ subject.should_receive(:rest_client).and_return(rest_client) }
     it{ capture{ subject.send(:scope_help) }.should =~ /scope_1.*A description/ }
     it{ capture{ subject.send(:scope_help) }.should =~ /scope_2.*Another description/ }
@@ -129,7 +129,7 @@ describe RHC::Commands::Authorization do
     context "with options" do
       let(:arguments) { ['authorization', 'add', '--scope', 'foo,bar', '--note', 'a_note', '--expires-in', '300'] }
       with_authorization
-      before{ stub_add_authorization(:note => 'a_note', :scope => 'foo,bar', :expires_in => '300') }
+      before{ challenge{ stub_add_authorization(:note => 'a_note', :scope => 'foo,bar', :expires_in => '300') } }
 
       it('should display success') { run_output.should =~ /Adding authorization.*done/ }
       it('should display the note')           { run_output.should =~ /a_note/ }

data/spec/rhc/commands/cartridge_spec.rb

@@ -53,7 +53,7 @@ describe RHC::Commands::Cartridge do
       it{ expect{ run }.to exit_with_code(0) }
 
       context 'with verbose list' do
-        let(:arguments){ ['cartridge', 'list', '--verbose'] }
+        let(:arguments){ ['cartridge', 'list', '--verbose', '--trace'] }
         it{ run_output.should match /Mock1 Cart.*\[mock_standalone_cart\-1\] \(web\)/ }
         it{ run_output.should match /mock_standalone_cart\-2 \(web\)/ }
         it{ run_output.should match "Mock2 description\n\n" }
@@ -217,8 +217,8 @@ describe RHC::Commands::Cartridge do
       let(:server){ mock_uri }
       let(:arguments){ ['remove-cartridge', 'jenkins-1.4', '-a', 'foo', '--confirm', '--trace'] }
       before do 
-        stub_api(true)
-        stub_one_domain('test')
+        stub_api(false)
+        challenge{ stub_one_domain('test') }
         stub_one_application('test', 'foo').with(:query => {:include => 'cartridges'})
         stub_application_cartridges('test', 'foo', [{:name => 'php-5.3'}, {:name => 'jenkins-1.4'}])
       end

data/spec/rhc/commands/domain_spec.rb

@@ -17,7 +17,7 @@ describe RHC::Commands::Domain do
       let(:arguments) { ['domain', '--noprompt', '--help'] }
 
       it { expect { run }.to exit_with_code(0) }
-      it { run_output.should match(/The default action for this resource is 'show'/) }
+      it { run_output.should match(/The default action for this resource is 'list'/) }
     end
   end
 
@@ -87,6 +87,56 @@ describe RHC::Commands::Domain do
     end
   end
 
+
+  describe 'list' do
+    let(:arguments) { ['domain', 'list'] }
+
+    context 'when run with no domains' do
+      it { expect { run }.to exit_with_code(1) }
+      it { run_output.should match(/In order to deploy applications.*rhc create-domain/) }
+    end
+
+    context 'when run with one domain no apps' do
+      before{ rest_client.add_domain("onedomain") }
+
+      it { expect { run }.to exit_with_code(0) }
+      it "should match output" do
+        output = run_output
+        output.should match("You have access to 1 domain\\.")
+        output.should match("onedomain")
+      end
+    end
+
+    context 'when run with one owned domain' do
+      let(:arguments) { ['domains', '--mine'] }
+      before{ d = rest_client.add_domain('mine', true); rest_client.stub(:owned_domains).and_return([d]) }
+
+      it { expect { run }.to exit_with_code(0) }
+      it "should match output" do
+        output = run_output
+        output.should match("You have access to 1 domain\\.")
+        output.should match("mine")
+        output.should match("Created")
+        output.should match("Allowed Gear Sizes: small")
+      end
+    end
+
+    context 'when run with multiple domains and extra domain info' do
+      before(:each) do
+        rest_client.add_domain("firstdomain")
+        rest_client.add_domain("seconddomain", true)
+      end
+      it { expect { run }.to exit_with_code(0) }
+      it "should match output" do
+        output = run_output
+        output.should match("You have access to 2 domains")
+        output.should match("seconddomain \\(owned by a_user_name\\)")
+        output.should match("Created")
+        output.should match("Allowed Gear Sizes: small")
+      end
+    end
+  end
+
   describe 'create' do
     let(:arguments) { ['domain', 'create', '--noprompt', '--config', 'test.conf', '-l', 'test@test.foo', '-p',  'password', 'testnamespace'] }
 

data/spec/rhc/commands/logout_spec.rb

@@ -14,9 +14,9 @@ describe RHC::Commands::Logout do
     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(0).times.and_return(token_store)
+      stub_api(false, supports_auth)
+      challenge{ stub_user }
+      RHC::Auth::TokenStore.stub(:new).and_return(token_store)
     end
 
     context "when calling from the alias" do

data/spec/rhc/commands/port_forward_spec.rb

@@ -14,7 +14,7 @@ describe RHC::Commands::PortForward do
       @domain = rest_client.add_domain("mockdomain")
       @app = @domain.add_application 'mockapp', 'mock-1.0'
       @uri = URI.parse @app.ssh_url
-      @ssh = mock(Net::SSH)
+      @ssh = double(Net::SSH)
     end
 
     context 'when port forwarding for a down appl' do
@@ -63,7 +63,7 @@ describe RHC::Commands::PortForward do
       before(:each) do
         Net::SSH.should_receive(:start).with(@uri.host, @uri.user).and_yield(@ssh).twice
         @ssh.should_receive(:exec!).with("rhc-list-ports").and_yield(nil, :stderr, 'mysql -> 127.0.0.1:3306')
-        forward = mock(Net::SSH::Service::Forward)
+        forward = double(Net::SSH::Service::Forward)
         @ssh.should_receive(:forward).and_return(forward)
         forward.should_receive(:local).with(3306, '127.0.0.1', 3306)
         @ssh.should_receive(:loop)
@@ -102,7 +102,7 @@ describe RHC::Commands::PortForward do
       before(:each) do
         Net::SSH.should_receive(:start).with(@uri.host, @uri.user).and_yield(@ssh).twice
         @ssh.should_receive(:exec!).with("rhc-list-ports").and_yield(nil, :stderr, 'mysql -> 127.0.0.1:3306')
-        forward = mock(Net::SSH::Service::Forward)
+        forward = double(Net::SSH::Service::Forward)
         @ssh.should_receive(:forward).and_return(forward)
         forward.should_receive(:local).with(3306, '127.0.0.1', 3306)
         @ssh.should_receive(:loop).and_raise(Interrupt.new)
@@ -120,7 +120,7 @@ describe RHC::Commands::PortForward do
       before(:each) do
         Net::SSH.should_receive(:start).with(@uri.host, @uri.user).and_yield(@ssh).twice
         @ssh.should_receive(:exec!).with("rhc-list-ports").and_yield(nil, :stderr, 'mysql -> 127.0.0.1:3306')
-        forward = mock(Net::SSH::Service::Forward)
+        forward = double(Net::SSH::Service::Forward)
         @ssh.should_receive(:forward).at_least(2).and_return(forward)
         forward.should_receive(:local).with(3306, '127.0.0.1', 3306).and_raise(Errno::EACCES)
         forward.should_receive(:local).with(3307, '127.0.0.1', 3306)
@@ -135,7 +135,7 @@ describe RHC::Commands::PortForward do
       before(:each) do
         Net::SSH.should_receive(:start).with(@uri.host, @uri.user).and_yield(@ssh).twice
         @ssh.should_receive(:exec!).with("rhc-list-ports").and_yield(nil, :stderr, 'mysql -> 127.0.0.1:3306')
-        forward = mock(Net::SSH::Service::Forward)
+        forward = double(Net::SSH::Service::Forward)
         @ssh.should_receive(:forward).and_raise(Errno::ECONNREFUSED)
       end
       it "should error out" do
@@ -154,7 +154,7 @@ describe RHC::Commands::PortForward do
         Net::SSH.should_receive(:start).with(@uri.host, @uri.user).and_yield(@ssh).twice
         @ssh.should_receive(:exec!).with("rhc-list-ports").
           and_yield(nil, :stderr, "httpd -> #{haproxy_host_1}:8080\nhttpd -> #{haproxy_host_2}:8080\nmongodb -> #{mongo_host}:35541\nmysqld -> #{ipv6_host}:3306")
-        forward = mock(Net::SSH::Service::Forward)
+        forward = double(Net::SSH::Service::Forward)
         @ssh.should_receive(:forward).at_least(3).times.and_return(forward)
         forward.should_receive(:local).with(8080, haproxy_host_1, 8080)
         forward.should_receive(:local).with(8080, haproxy_host_2, 8080).and_raise(Errno::EADDRINUSE)
@@ -183,7 +183,7 @@ describe RHC::Commands::PortForward do
 
         @ssh.should_receive(:exec!).with("rhc-list-ports --exclude-remote").
           and_yield(nil, :stderr, "mongodb -> #{gear_host}:35541")
-        forward = mock(Net::SSH::Service::Forward)
+        forward = double(Net::SSH::Service::Forward)
         @ssh.should_receive(:forward).and_return(forward)
         forward.should_receive(:local).with(35541, gear_host, 35541)
         @ssh.should_receive(:loop).and_raise(Interrupt.new)

data/spec/rhc/commands/server_spec.rb

@@ -11,13 +11,13 @@ describe RHC::Commands::Server do
     let(:arguments) { ['server', '--server', 'foo.com', '-l', 'person', '-p', ''] }
 
     context 'when server refuses connection' do
-      before { stub_request(:get, 'https://foo.com/broker/rest/api').with(&user_agent_header).with(&expect_authorization(:user => 'person')).to_raise(SocketError) }
+      before { stub_request(:get, 'https://foo.com/broker/rest/api').with(&user_agent_header).to_raise(SocketError) }
       it('should output an error') { run_output.should =~ /Connected to foo.com.*Unable to connect to the server/m }
       it { expect { run }.to exit_with_code(1) }
     end
 
     context 'when API is missing' do
-      before { stub_request(:get, 'https://foo.com/broker/rest/api').with(&user_agent_header).with(&expect_authorization(:user => 'person')).to_return(:status => 404) }
+      before { stub_request(:get, 'https://foo.com/broker/rest/api').with(&user_agent_header).to_return(:status => 404) }
       it('should output an error') { run_output.should =~ /Connected to foo.com.*server is not responding correctly/m }
       it { expect { run }.to exit_with_code(1) }
     end

data/spec/rhc/commands/setup_spec.rb

@@ -17,9 +17,9 @@ describe RHC::Commands::Setup do
     let(:arguments) { ['setup', '--config', 'test.conf', '-l', 'test@test.foo', '-p',  'password'] }
 
     before(:each) do
-      @wizard = mock('wizard')
-      @wizard.stub!(:run).and_return(true)
-      RHC::RerunWizard.stub!(:new){ @wizard }
+      @wizard = double('wizard')
+      @wizard.stub(:run).and_return(true)
+      RHC::RerunWizard.stub(:new){ @wizard }
     end
 
     context 'when no issues' do
@@ -30,7 +30,7 @@ describe RHC::Commands::Setup do
 
     context 'when there is an issue' do
       it "should exit 1" do
-        @wizard.stub!(:run).and_return(false)
+        @wizard.stub(:run).and_return(false)
         expect { run }.to exit_with_code(1)
       end
     end
@@ -54,7 +54,7 @@ describe RHC::Commands::Setup do
   end
 
 =begin  context 'when libra_server is set' do
-    before{ ENV.should_receive(:[]).any_number_of_times.with('LIBRA_SERVER').and_return('bar.com') }
+    before{ ENV.stub(:[]).with('LIBRA_SERVER').and_return('bar.com') }
     it{ command_for('setup').config['libra_server'].should == 'bar.com' }
     it{ command_for('setup').options.server.should == 'bar.com' }
     it{ command_for('setup', '--server', 'foo.com').options.server.should == 'foo.com' }
@@ -95,7 +95,7 @@ describe RHC::Commands::Setup do
 
     context 'help is run' do
       it "should display help" do
-        @wizard.stub!(:run).and_return(true)
+        @wizard.stub(:run).and_return(true)
         expect { run }.to exit_with_code(0)
       end
       it('should output usage') { run_output.should match("Connects to an OpenShift server to get you started. Will") }

data/spec/rhc/commands/snapshot_spec.rb

@@ -51,7 +51,7 @@ describe RHC::Commands::Snapshot do
         RHC::Helpers.stub(:windows?) do ; true; end
         RHC::Helpers.stub(:jruby?) do ; false ; end
         RHC::Helpers.stub(:linux?) do ; false ; end
-        ssh = mock(Net::SSH)
+        ssh = double(Net::SSH)
         Net::SSH.should_receive(:start).with(@ssh_uri.host, @ssh_uri.user).and_yield(ssh)
         ssh.should_receive(:exec!).with("snapshot").and_yield(nil, :stdout, 'foo').and_yield(nil, :stderr, 'foo')
       end
@@ -64,7 +64,7 @@ describe RHC::Commands::Snapshot do
         RHC::Helpers.stub(:windows?) do ; true; end
         RHC::Helpers.stub(:jruby?) do ; false ; end
         RHC::Helpers.stub(:linux?) do ; false ; end
-        ssh = mock(Net::SSH)
+        ssh = double(Net::SSH)
         Net::SSH.should_receive(:start).with(@ssh_uri.host, @ssh_uri.user).and_raise(Timeout::Error)
       end
       it { expect { run }.to exit_with_code(130) }
@@ -77,8 +77,8 @@ describe RHC::Commands::Snapshot do
 
     context 'when restoring a snapshot' do
       before(:each) do
-        File.stub!(:exists?).and_return(true)
-        RHC::TarGz.stub!(:contains).and_return(true)
+        File.stub(:exists?).and_return(true)
+        RHC::TarGz.stub(:contains).and_return(true)
         `(exit 0)`
         Kernel.should_receive(:`).with("cat #{@app.name}.tar.gz | ssh #{@ssh_uri.user}@#{@ssh_uri.host} 'restore INCLUDE_GIT'")
       end
@@ -87,8 +87,8 @@ describe RHC::Commands::Snapshot do
 
     context 'when restoring a snapshot and failing to ssh' do
       before(:each) do
-        File.stub!(:exists?).and_return(true)
-        RHC::TarGz.stub!(:contains).and_return(true)
+        File.stub(:exists?).and_return(true)
+        RHC::TarGz.stub(:contains).and_return(true)
         Kernel.should_receive(:`).with("cat #{@app.name}.tar.gz | ssh #{@ssh_uri.user}@#{@ssh_uri.host} 'restore INCLUDE_GIT'")
         $?.stub(:exitstatus) { 1 }
       end
@@ -100,9 +100,9 @@ describe RHC::Commands::Snapshot do
         RHC::Helpers.stub(:windows?) do ; true; end
         RHC::Helpers.stub(:jruby?) do ; false ; end
         RHC::Helpers.stub(:linux?) do ; false ; end
-        ssh = mock(Net::SSH)
-        session = mock(Net::SSH::Connection::Session)
-        channel = mock(Net::SSH::Connection::Channel)
+        ssh = double(Net::SSH)
+        session = double(Net::SSH::Connection::Session)
+        channel = double(Net::SSH::Connection::Channel)
         Net::SSH.should_receive(:start).with(@ssh_uri.host, @ssh_uri.user).and_return(session)
         session.should_receive(:open_channel).and_yield(channel)
         channel.should_receive(:exec).with("restore INCLUDE_GIT").and_yield(nil, nil)
@@ -127,7 +127,7 @@ describe RHC::Commands::Snapshot do
         RHC::Helpers.stub(:windows?) do ; true; end
         RHC::Helpers.stub(:jruby?) do ; false ; end
         RHC::Helpers.stub(:linux?) do ; false ; end
-        ssh = mock(Net::SSH)
+        ssh = double(Net::SSH)
         Net::SSH.should_receive(:start).with(@ssh_uri.host, @ssh_uri.user).and_raise(Timeout::Error)
       end
       it { expect { run }.to exit_with_code(130) }