rhc 1.6.8 → 1.7.8

data/spec/rhc/commands/app_spec.rb

@@ -6,12 +6,13 @@ require 'resolv'
 
 describe RHC::Commands::App do
   let!(:rest_client){ MockRestClient.new }
-  before(:each) do
+  let!(:config){ user_config }
+  before{ RHC::Config.stub(:home_dir).and_return('/home/mock_user') }
+  before do
     FakeFS.activate!
     FakeFS::FileSystem.clear
-    user_config
-    RHC::Helpers::remove_const(:MAX_RETRIES) rescue nil
-    RHC::Helpers::const_set(:MAX_RETRIES, 3)
+    RHC::Helpers.send(:remove_const, :MAX_RETRIES) rescue nil
+    RHC::Helpers.const_set(:MAX_RETRIES, 3)
     @instance = RHC::Commands::App.new
     RHC::Commands::App.stub(:new) do
       @instance.stub(:git_config_get) { "" }
@@ -38,7 +39,7 @@ describe RHC::Commands::App do
     end
 
     context 'app' do
-      let(:arguments) { ['app', '--noprompt', '--config', 'test.conf', '-l', 'test@test.foo', '-p',  'password'] }
+      let(:arguments) { ['app'] }
       it { run_output.should match('Usage:') }
     end
   end
@@ -49,9 +50,116 @@ describe RHC::Commands::App do
     it("shows number of started"){ subject.send(:gear_group_state, ['started', 'idle']).should == '1/2 started' }
   end
 
+  describe '#check_domain!' do
+    let(:rest_client){ stub('RestClient') }
+    let(:domain){ stub('Domain', :id => 'test') }
+    before{ subject.stub(:rest_client).and_return(rest_client) }
+    let(:interactive){ false }
+    before{ subject.stub(:interactive?).and_return(interactive) }
+
+    context "when no options are provided and there is one domain" do
+      before{ rest_client.should_receive(:domains).twice.and_return([domain]) }
+      it("should load the first domain"){ subject.send(:check_domain!).should == domain }
+      after{ subject.send(:options).namespace.should == domain.id }
+    end
+
+    context "when no options are provided and there are no domains" do
+      before{ rest_client.should_receive(:domains).and_return([]) }
+      it("should load the first domain"){ expect{ subject.send(:check_domain!) }.to raise_error(RHC::Rest::DomainNotFoundException) }
+      after{ subject.send(:options).namespace.should be_nil }
+    end
+
+    context "when valid namespace is provided" do
+      before{ subject.send(:options)[:namespace] = 'test' }
+      before{ rest_client.should_receive(:find_domain).with('test').and_return(domain) }
+      it("should load the requested domain"){ subject.send(:check_domain!).should == domain }
+      after{ subject.send(:options).namespace.should == 'test' }
+    end
+
+    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)) }
+      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
+  end
+
   describe 'app create' do
-    before(:each) do
-      domain = rest_client.add_domain("mockdomain")
+    before{ rest_client.add_domain("mockdomain") }
+
+    context "when we ask for help with the alias" do
+      before{ FakeFS.deactivate! }
+      context do
+        let(:arguments) { ['help', 'create-app'] }
+        it{ run_output.should match "Usage: rhc app-create <name>" }
+      end
+      context do
+        let(:arguments) { ['create-app', '-h'] }
+        it{ run_output.should match "Usage: rhc app-create <name>" }
+      end
+    end
+
+    context "when run with no arguments" do
+      before{ FakeFS.deactivate! }
+      let(:arguments){ ['create-app'] }
+      it{ run_output.should match "Usage: rhc app-create <name>" }
+      it{ run_output.should match "When creating an application, you must provide a name and a cartridge from the list below:" }
+      it{ run_output.should match "mock_standalone_cart-1" }
+      it{ run_output.should match "Please specify the name of the application" }
+    end
+
+    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(:options){ nil }
+      let(:interactive){ true }
+      before{ subject.should_receive(:interactive?).at_least(1).times.and_return(interactive) }
+      before{ subject.stub(:check_sshkeys!) }
+
+      it("should run the wizard"){ expect{ subject.create('name', ['mock_standalone_cart-1']) }.to call(:run).on(wizard).and_stop }
+
+      context "when has config" do
+        let(:options){ {:server => 'test', :rhlogin => 'foo'} }
+        before{ subject.send(:config).should_receive(:has_local_config?).and_return(true) }
+        it("should not run the wizard"){ expect{ subject.create('name', ['mock_standalone_cart-1']) }.to not_call(:new).on(RHC::EmbeddedWizard) }
+      end
+
+      context "when has no config" do
+        before{ subject.send(:config).should_receive(:has_local_config?).and_return(false) }
+        it("should run the wizard"){ expect{ subject.create('name', ['mock_standalone_cart-1']) }.to call(:new).on(RHC::EmbeddedWizard).and_stop }
+      end
+
+      context "when not interactive" do
+        let(:interactive){ false }
+        it("should not run the wizard"){ expect{ subject.create('name', ['mock_standalone_cart-1']) }.to not_call(:new).on(RHC::EmbeddedWizard) }
+      end
+    end
+
+    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(: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) }
+      before{ subject.should_receive(:check_config!) }
+
+      it("should run the wizard"){ expect{ subject.create('name', ['mock_standalone_cart-1']) }.to call(:run).on(wizard).and_stop }
+
+      context "when not interactive" do
+        let(:interactive){ false }
+        it("should not run the wizard"){ expect{ subject.create('name', ['mock_standalone_cart-1']) }.to not_call(:new).on(RHC::SSHWizard) }
+      end
+    end
+
+    context "when in full interactive mode with no keys, domain, or config" do
+      let!(:config){ base_config }
+      before{ RHC::Config.any_instance.stub(:has_local_config?).and_return(false) }
+      before{ described_class.any_instance.stub(:interactive?).and_return(true) }
+      before{ rest_client.domains.clear }
+      let(:arguments) { ['app', 'create', 'app1', 'mock_standalone_cart-1'] }
+      # skips login stage and insecure check because of mock rest client, doesn't check keys
+      it { run_output(['mydomain', 'y', 'mykey']).should match(/This wizard.*Checking your namespace.*Your domain name 'mydomain' has been successfully created.*Creating application.*Your public SSH key.*Uploading key 'mykey' .*Downloading the application.*Success/m) }
     end
 
     context 'when run without a cart' do
@@ -62,7 +170,7 @@ describe RHC::Commands::App do
 
     context 'when run with a valid cart' do
       let(:arguments) { ['app', 'create', 'app1', 'mock_standalone_cart-1', '--noprompt', '--timeout', '10', '--config', 'test.conf', '-l', 'test@test.foo', '-p',  'password'] }
-      it { expect { run }.should exit_with_code(0) }
+      it { expect { run }.to exit_with_code(0) }
       it { run_output.should match("Success") }
       it { run_output.should match("Cartridges: mock_standalone_cart-1\n") }
     end
@@ -75,13 +183,13 @@ describe RHC::Commands::App do
         resolver.should_receive(:getaddress).with('app1-mockdomain.fake.foo').and_raise(ArgumentError)
       end
 
-      it { expect { run }.should exit_with_code(0) }
+      it { expect { run }.to exit_with_code(0) }
       it { run_output.should match("Success") }
     end
 
     context 'when run with multiple carts' do
       let(:arguments) { ['app', 'create', 'app1', 'mock_standalone_cart-1', 'mock_cart-1', '--noprompt', '-p',  'password'] }
-      it { expect { run }.should exit_with_code(0) }
+      it { expect { run }.to exit_with_code(0) }
       it { run_output.should match("Success") }
       it { run_output.should match("Cartridges: mock_standalone_cart-1, mock_cart-1\n") }
       after{ rest_client.domains.first.applications.first.cartridges.find{ |c| c.name == 'mock_cart-1' }.should be_true }
@@ -89,7 +197,7 @@ describe RHC::Commands::App do
 
     context 'when run with a git url' do
       let(:arguments) { ['app', 'create', 'app1', 'mock_standalone_cart-1', '--from', 'git://url', '--noprompt', '-p',  'password'] }
-      it { expect { run }.should exit_with_code(0) }
+      it { expect { run }.to exit_with_code(0) }
       it { run_output.should match("Success") }
       it { run_output.should match("Source Code: git://url\n") }
       it { run_output.should match("Initial Git URL: git://url\n") }
@@ -106,7 +214,7 @@ describe RHC::Commands::App do
       end
       context 'with trace' do
         let(:arguments) { ['app', 'create', 'app1', 'nomatch_cart', '--noprompt', '--config', 'test.conf', '-l', 'test@test.foo', '-p',  'password', '--trace'] }
-        it { expect { run }.should raise_error(RHC::CartridgeNotFoundException, "There are no cartridges that match 'nomatch_cart'.") }
+        it { expect { run }.to raise_error(RHC::CartridgeNotFoundException, "There are no cartridges that match 'nomatch_cart'.") }
       end
     end
 
@@ -119,7 +227,7 @@ describe RHC::Commands::App do
 
     context 'multiple web matches' do
       let(:arguments) { ['app', 'create', 'app1', 'mock_standalone_cart', '--trace', '--noprompt'] }
-      it { expect { run }.should raise_error(RHC::MultipleCartridgesException) }
+      it { expect { run }.to raise_error(RHC::MultipleCartridgesException) }
     end
     context 'when only a single cart can match' do
       let(:arguments) { ['app', 'create', 'app1', 'unique', '--trace', '--noprompt'] }
@@ -135,15 +243,15 @@ describe RHC::Commands::App do
     end
     context 'when I pick only embedded carts' do
       let(:arguments) { ['app', 'create', 'app1', 'mock_cart', '--trace', '--noprompt'] }
-      it { expect { run }.should raise_error(RHC::CartridgeNotFoundException, /Every application needs a web cartridge/) }
+      it { expect { run }.to raise_error(RHC::CartridgeNotFoundException, /Every application needs a web cartridge/) }
     end
     context 'when I pick multiple embedded carts' do
       let(:arguments) { ['app', 'create', 'app1', 'unique_standalone', 'mock_cart', '--trace', '--noprompt'] }
-      it { expect { run }.should raise_error(RHC::MultipleCartridgesException, /There are multiple cartridges matching 'mock_cart'/) }
+      it { expect { run }.to raise_error(RHC::MultipleCartridgesException, /There are multiple cartridges matching 'mock_cart'/) }
     end
     context 'when I pick multiple standalone carts' do
       let(:arguments) { ['app', 'create', 'app1', 'unique_standalone', 'mock_standalone_cart', '--trace', '--noprompt'] }
-      it { expect { run }.should raise_error(RHC::MultipleCartridgesException, /You must select only a single web cart/) }
+      it { expect { run }.to raise_error(RHC::MultipleCartridgesException, /You must select only a single web cart/) }
     end
   end
 
@@ -156,7 +264,7 @@ describe RHC::Commands::App do
       end
       it "should create a jenkins app and a regular app with an embedded jenkins client" do
         #puts run_output
-        expect { run }.should exit_with_code(0)
+        expect { run }.to exit_with_code(0)
         jenkins_app = rest_client.find_application(@domain.id,"jenkins")
         jenkins_app.cartridges[0].name.should == "jenkins-1.4"
         app = rest_client.find_application(@domain.id,"app1")
@@ -172,7 +280,7 @@ describe RHC::Commands::App do
       before(:each) do
         domain = rest_client.add_domain("mockdomain")
       end
-      it { expect { run }.should_not raise_error(ArgumentError, /The --no-dns option can't be used in conjunction with --enable-jenkins/) }
+      it { expect { run }.to_not raise_error(ArgumentError, /The --no-dns option can't be used in conjunction with --enable-jenkins/) }
     end
   end
 
@@ -183,7 +291,7 @@ describe RHC::Commands::App do
       before(:each) do
         domain = rest_client.add_domain("mockdomain")
       end
-      it { expect { run }.should raise_error(ArgumentError, /You have named both your main application and your Jenkins application/) }
+      it { expect { run }.to raise_error(ArgumentError, /You have named both your main application and your Jenkins application/) }
     end
   end
 
@@ -196,9 +304,9 @@ describe RHC::Commands::App do
         @domain.add_application("jenkins", "jenkins-1.4")
       end
       it "should use existing jenkins" do
-        expect { run }.should exit_with_code(0)
-        expect { rest_client.find_application(@domain.id,"jenkins") }.should_not raise_error
-        expect { rest_client.find_application(@domain.id,"jenkins2") }.should raise_error(RHC::Rest::ApplicationNotFoundException)
+        expect { run }.to exit_with_code(0)
+        expect { rest_client.find_application(@domain.id,"jenkins") }.to_not raise_error
+        expect { rest_client.find_application(@domain.id,"jenkins2") }.to raise_error(RHC::Rest::ApplicationNotFoundException)
       end
     end
   end
@@ -261,7 +369,7 @@ describe RHC::Commands::App do
     before(:each) do
       @domain = rest_client.add_domain("mockdomain")
       @instance.stub(:git_clone_application) { raise RHC::GitException }
-      @instance.should_not_receive(:check_sshkeys!)
+      @instance.stub(:check_sshkeys!)
     end
 
     context 'when run with error in git clone' do
@@ -324,7 +432,7 @@ describe RHC::Commands::App do
     end
 
     context 'when run' do
-      it { expect { run }.should exit_with_code(0) }
+      it { expect { run }.to exit_with_code(0) }
     end
   end
 
@@ -335,34 +443,34 @@ describe RHC::Commands::App do
       before{ @domain = rest_client.add_domain("mockdomain") }
 
       it "should raise cartridge not found exception when no apps exist" do
-        expect { run }.should raise_error RHC::Rest::ApplicationNotFoundException
+        expect { run }.to raise_error RHC::Rest::ApplicationNotFoundException
       end
 
       context "with an app" do
         before{ @app = @domain.add_application("app1", "mock_type") }
 
         it "should not remove app when no is sent as input" do
-          expect { run(["no"]) }.should raise_error(RHC::ConfirmationError)
+          expect { run(["no"]) }.to raise_error(RHC::ConfirmationError)
           @domain.applications.length.should == 1
           @domain.applications[0] == @app
         end
 
         it "should remove app when yes is sent as input" do
-          expect { run(["yes"]) }.should exit_with_code(0)
+          expect { run(["yes"]) }.to exit_with_code(0)
           @domain.applications.length.should == 0
         end
 
         context "with --noprompt but without --confirm" do
           let(:arguments) { ['app', 'delete', 'app1', '--noprompt', '--trace'] }
           it "should not remove the app" do
-            expect { run(["no"]) }.should raise_error(RHC::ConfirmationError)
+            expect { run(["no"]) }.to raise_error(RHC::ConfirmationError)
             @domain.applications.length.should == 1
           end
         end
         context "with --noprompt and --confirm" do
           let(:arguments) { ['app', 'delete', 'app1', '--noprompt', '--confirm'] }
           it "should remove the app" do
-            expect { run }.should exit_with_code(0)
+            expect { run }.to exit_with_code(0)
             @domain.applications.length.should == 0
           end
         end
@@ -445,7 +553,7 @@ describe RHC::Commands::App do
         Kernel.should_receive(:system).with("ssh fakeuuidfortestsapp1@127.0.0.1").and_return(0)
       end
       it { run_output.should match("Connecting to fakeuuidfortestsapp") }
-      it { expect { run }.should exit_with_code(0) }
+      it { expect { run }.to exit_with_code(0) }
     end
   end
 
@@ -459,7 +567,7 @@ describe RHC::Commands::App do
         @instance.should_receive(:has_ssh?).and_return(false)
       end
       it { run_output.should match("Please use the --ssh option to specify the path to your SSH executable, or install SSH.") }
-      it { expect { run }.should exit_with_code(1) }
+      it { expect { run }.to exit_with_code(1) }
     end
   end
 
@@ -474,7 +582,7 @@ describe RHC::Commands::App do
         Kernel.should_receive(:system).with("path_to_ssh fakeuuidfortestsapp1@127.0.0.1").and_return(1)
       end
       it { run_output.should match("Connecting to fakeuuidfortestsapp") }
-      it { expect { run }.should exit_with_code(1) }
+      it { expect { run }.to exit_with_code(1) }
     end
   end
 
@@ -496,7 +604,7 @@ describe RHC::Commands::App do
         @domain.add_application("app1", "mock_type")
       end
       it { run_output.should match("started") }
-      it { run_output.should match("deprecated") }
+      it("should warn about deprecation") { run_output.should match("deprecated") }
     end
   end
 

data/spec/rhc/commands/apps_spec.rb

@@ -10,7 +10,7 @@ describe RHC::Commands::Apps do
     context 'when no domains' do
       let(:arguments) { ['apps'] }
 
-      it { expect { run }.should exit_with_code(1) }
+      it { expect { run }.to exit_with_code(1) }
       it { run_output.should match(/In order to deploy applications.*rhc domain create/) }
     end
 
@@ -18,21 +18,21 @@ describe RHC::Commands::Apps do
       let(:arguments){ ['apps'] }
       let!(:domain){ rest_client.add_domain("first") }
 
-      it { expect { run }.should exit_with_code(1) }
+      it { expect { run }.to exit_with_code(1) }
       it { run_output.should match(/No applications.*rhc app create/) }
 
       context 'with apps' do
         let(:arguments) { ['apps'] }
         before{ domain.add_application('scaled', 'php', true) }
 
-        it { expect { run }.should exit_with_code(0) }
+        it { expect { run }.to exit_with_code(0) }
         it { run_output.should match(/scaled.*\-\-.*php.*Scaling:.*x2 \(minimum/m) }
       end
     end
 
     context 'when help is shown' do
       let(:arguments) { ['apps', '--help'] }
-      it { expect { run }.should exit_with_code(0) }
+      it { expect { run }.to exit_with_code(0) }
       it { run_output.should match(/rhc apps.*Display the list of applications/m) }
     end
   end

data/spec/rhc/commands/authorization_spec.rb

@@ -23,7 +23,7 @@ describe RHC::Commands::Authorization do
     context "without authorizations" do
       without_authorization
       it('should warn that the server doesn\'t support auth'){ run_output.should =~ /The server does not support setting, retrieving, or authenticating with authorization tokens/ }
-      it{ expect{ run }.should exit_with_code(1) }
+      it{ expect{ run }.to exit_with_code(1) }
     end
   end
 
@@ -37,7 +37,7 @@ describe RHC::Commands::Authorization do
       it('should display the expiration')     { run_output.should =~ /Expires In:\s+1 minute/ }
       it('should display the creation date')  { run_output.should =~ /Created:\s+#{RHC::Helpers.date('2013-02-21T01:00:01Z')}/ }
       it('should display the scopes')         { run_output.should =~ /Scopes:\s+session read/ }
-      it{ expect{ run }.should exit_with_code(0) }
+      it{ expect{ run }.to exit_with_code(0) }
     end
 
     expect_an_unsupported_message
@@ -47,7 +47,7 @@ describe RHC::Commands::Authorization do
     let(:arguments) { ['authorization', '--h']}
     context 'given --h' do
       it 'should not raise SystemStackError' do
-        expect{ run }.should_not raise_error(SystemStackError)
+        expect{ run }.to_not raise_error(SystemStackError)
       end
     end
   end
@@ -60,7 +60,7 @@ describe RHC::Commands::Authorization do
       before{ stub_delete_authorization('foo') }
       before{ stub_delete_authorization('bar') }
       it('should display success') { run_output.should =~ /Deleting auth.*done/ }
-      it{ expect{ run }.should exit_with_code(0) }
+      it{ expect{ run }.to exit_with_code(0) }
       after{ a_request(:delete, mock_href('broker/rest/user/authorizations/foo', true)).should have_been_made }
       after{ a_request(:delete, mock_href('broker/rest/user/authorizations/bar', true)).should have_been_made }
     end
@@ -68,7 +68,7 @@ describe RHC::Commands::Authorization do
     context "without a token in the command line" do
       let(:arguments) { ['authorization', 'delete'] }
       it('should display success') { run_output.should =~ /You must specify one or more tokens to delete/ }
-      it{ expect{ run }.should exit_with_code(1) }
+      it{ expect{ run }.to exit_with_code(1) }
     end
 
     expect_an_unsupported_message
@@ -81,7 +81,7 @@ describe RHC::Commands::Authorization do
       with_authorization
       before{ stub_delete_authorizations }
       it('should display success') { run_output.should =~ /Deleting all auth.*done/ }
-      it{ expect{ run }.should exit_with_code(0) }
+      it{ expect{ run }.to exit_with_code(0) }
       after{ a_request(:delete, mock_href('broker/rest/user/authorizations', true)).should have_been_made }
     end
 
@@ -105,7 +105,7 @@ describe RHC::Commands::Authorization do
       before{ instance.should_receive(:scope_help) }
 
       it('should display the scope help') { command_output.should =~ /When adding an authorization.*to see more options/m }
-      it{ expect{ run_command }.should exit_with_code(0) }
+      it{ expect{ run_command }.to exit_with_code(0) }
     end
 
     expect_an_unsupported_message
@@ -121,7 +121,7 @@ describe RHC::Commands::Authorization do
       it('should display the expiration')     { run_output.should =~ /Expires In:\s+5 minutes/ }
       it('should display the creation date')  { run_output.should =~ /Created:\s+#{RHC::Helpers.date(mock_date_1)}/ }
       it('should display the scopes')         { run_output.should =~ /Scopes:\s+foo bar/ }
-      it{ expect{ run }.should exit_with_code(0) }
+      it{ expect{ run }.to exit_with_code(0) }
 
       expect_an_unsupported_message
     end

data/spec/rhc/commands/cartridge_spec.rb

@@ -6,7 +6,7 @@ require 'rhc/config'
 describe RHC::Commands::Cartridge do
 
   def exit_with_code_and_message(code, message = nil)
-    expect{ run }.should exit_with_code(code)
+    expect{ run }.to exit_with_code(code)
     run_output.should match(message) if message
   end
 
@@ -50,7 +50,7 @@ describe RHC::Commands::Cartridge do
       it{ run_output.should match /mock_standalone_cart\-2\s+web/ }
       it{ run_output.should match /mock_embedded_cart\-1\s+Mock1 Embedded Cart\s+addon/ }
       it{ run_output.should match /premium_cart\-1 \(\*\)\s+Premium Cart\s+web/ }
-      it{ expect{ run }.should exit_with_code(0) }
+      it{ expect{ run }.to exit_with_code(0) }
 
       context 'with verbose list' do
         let(:arguments){ ['cartridge', 'list', '--verbose'] }
@@ -200,12 +200,12 @@ describe RHC::Commands::Cartridge do
       end
       it "should remove cartridge" do
         @app.add_cartridge('mock_cart-1')
-        expect { run }.should exit_with_code(0)
+        expect { run }.to exit_with_code(0)
         # framework cart should be the only one listed
         @app.cartridges.length.should == 1
       end
       it "should raise cartridge not found exception" do
-        expect { run }.should raise_error RHC::CartridgeNotFoundException
+        expect { run }.to raise_error RHC::CartridgeNotFoundException
       end
     end
   end
@@ -398,7 +398,7 @@ describe RHC::Commands::Cartridge do
   end
 
   describe 'cartridge storage' do
-    let!(:rest_client){ MockRestClient.new }
+    let!(:rest_client){ MockRestClient.new(RHC::Config, 1.3) }
     let(:cmd_base) { ['cartridge', 'storage'] }
     let(:std_args) { ['-a', 'app1', '--noprompt', '--config', 'test.conf', '-l', 'test@test.foo', '-p',  'password'] | (@extra_args || []) }
     let(:cart_type) { ['mock_cart-1'] }
@@ -411,10 +411,8 @@ describe RHC::Commands::Cartridge do
 
     context 'when run with no arguments' do
       let(:arguments) { cmd_base | std_args }
-      it "should show a list of storage info for all carts" do
-        run_output.should match('mock_type')
-        run_output.should match('mock_cart-1')
-      end
+      it ("should show the mock_type"){ run_output.should match('mock_type') }
+      it ('should show mock_cart-1'){ run_output.should match('mock_cart-1') }
     end
 
     context 'when run for a non-existent cartridge' do
@@ -483,5 +481,16 @@ describe RHC::Commands::Cartridge do
         fail_with_message("The amount format must be a number, optionally followed by 'GB'")
       end
     end
+
+    context 'when run against an outdated broker' do
+      before { rest_client.stub(:api_version_negotiated).and_return(1.2) }
+      let(:arguments) { cmd_base | cart_type | std_args }
+
+      it 'adding storage should raise a version error' do
+        @extra_args = ["--add", "1GB"]
+        fail_with_message('The server does not support this command \(requires 1.3, found 1.2\).')
+      end
+
+    end
   end
 end