rhc 0.98.16 → 1.0.4

data/spec/rhc/commands/threaddump_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+require 'rest_spec_helper'
+require 'rhc/commands/threaddump'
+require 'rhc/config'
+describe RHC::Commands::Threaddump do
+  let(:client_links)   { mock_response_links(mock_client_links) }
+  let(:domain_0_links) { mock_response_links(mock_domain_links('mock_domain_0')) }
+  let(:domain_1_links) { mock_response_links(mock_domain_links('mock_domain_1')) }
+  let(:app_0_links)    { mock_response_links(mock_app_links('mock_domain_0', 'mock_app_0')) }
+  before(:each) do
+    RHC::Config.set_defaults
+    @rc = MockRestClient.new
+    @rc.add_domain("mock_domain_0").add_application("mock_app_0", "ruby-1.8.7")
+    stub_api_request(:any, client_links['LIST_DOMAINS']['relative']).with(:headers => {'Accept-Encoding'=>'gzip, deflate'}).
+            to_return({ :body   => {
+                          :type => 'domains',
+                          :data =>
+                          [{ :id    => 'mock_domain_0',
+                             :links => mock_response_links(mock_domain_links('mock_domain_0')),
+                           },
+                           { :id    => 'mock_domain_1',
+                             :links => mock_response_links(mock_domain_links('mock_domain_1')),
+                           }]
+                        }.to_json,
+                        :status => 200
+                      })
+    stub_api_request(:any, domain_0_links['LIST_APPLICATIONS']['relative']).with(:headers => {'Accept-Encoding'=>'gzip, deflate'}).
+            to_return({ :body   => {
+                    :type => 'applications',
+                    :data =>
+                    [{ :domain_id       => 'mock_domain_0',
+                       :name            => 'mock_app_0',
+                       :creation_time   => Time.new.to_s,
+                       :uuid            => 1234,
+                       :aliases         => ['alias_1', 'alias_2'],
+                       :server_identity => 'mock_server_identity',
+                       :links           => mock_response_links(mock_app_links('mock_domain_0','mock_app_0')),
+                     }]
+                  }.to_json,
+                  :status => 200
+                })
+    stub_api_request(:any, app_0_links['THREAD_DUMP']['relative']).with(:body => {:event => 'thread-dump'}, :headers => {'Accept-Encoding'=>'gzip, deflate', 'Content-Length'=>'17', 'Content-Type'=>'application/x-www-form-urlencoded'}).
+            to_return({ :body   => {
+                          :type => 'application',
+                          :data =>
+                          { :domain_id       => 'mock_domain_1',
+                             :name            => 'mock_app_0',
+                             :creation_time   => Time.new.to_s,
+                             :uuid            => 1234,
+                             :aliases         => ['alias_1', 'alias_2'],
+                             :server_identity => 'mock_server_identity',
+                             :links           => mock_response_links(mock_app_links('mock_domain_1','mock_app_0')),
+                           },
+                          :messages => [{:text => 'Application test thread dump complete.: Success'}]
+                        }.to_json,
+                        :status => 200
+                      })
+  end
+
+  describe 'help' do
+    let(:arguments) { ['threaddump', '--help'] }
+
+    context 'help is run' do
+      it "should display help" do
+        expect { run }.should exit_with_code(0)
+      end
+      it('should output usage') { run_output.should match("Usage: rhc threaddump") }
+    end
+  end
+
+  describe 'threaddump' do
+    let(:arguments) { ['threaddump', '--noprompt', '--config', 'test.conf', '-l', 'test@test.foo', '-p',  'password', 'mock_app_0'] }
+    context 'with no issues' do
+      it { expect { run }.should exit_with_code(0) }
+    end
+  end
+  describe 'threaddump no args' do
+    let(:arguments) { ['threaddump', '--noprompt', '--config', 'test.conf', '-l', 'test@test.foo', '-p',  'password'] }
+    context 'args not supplied' do
+      it { expect { run }.should exit_with_code(1) }
+    end
+  end
+end

data/spec/rhc/config_spec.rb

@@ -8,10 +8,10 @@ describe RHC::Config do
     ENV['http_proxy'] = nil
     mock_terminal
     FakeFS.activate!
+    FakeFS::FileSystem.clear
   end
 
   after(:all) do
-    FakeFS::FileSystem.clear
     FakeFS.deactivate!
   end
 
@@ -254,22 +254,48 @@ describe RHC::Config do
     end
   end
 
-  context "Odds and ends including error conditions" do
+  context "Proxy ENV variable parsing" do
+    before do
+      RHC::Config.initialize
+      ['http_proxy','HTTP_PROXY'].each do |var|
+        ENV[var] = nil
+      end
+    end
+
     it "should return a direct http connection" do
-      proxy = RHC::Config.default_proxy
-      proxy.should == Net::HTTP
+      RHC::Config.using_proxy?.should_not == true
     end
 
-    it "should retrun a proxy http connection" do
-      RHC::Config.initialize
-      ENV['http_proxy'] = "fakeproxy.foo:8080"
-      proxy = RHC::Config.default_proxy
-      # returns a generic class so we check to make sure it is not a
-      # Net::HTTP class and rely on simplecov to make sure the proxy
-      # code path was run
-      proxy.should_not == Net::HTTP
+    ['http_proxy','HTTP_PROXY'].each do |var|
+      it "should retrun a proxy http connection for #{var}" do
+        ENV[var] = "fakeproxy.foo:8080"
+        # returns a generic class so we check to make sure it is not a
+        # Net::HTTP class and rely on simplecov to make sure the proxy
+        # code path was run
+        RHC::Config.using_proxy?.should == true
+      end
     end
 
+    context "it should have the correct values" do
+      let(:vars){ RHC::Config.proxy_vars }
+      before do
+        ENV['http_proxy'] = "my_user:my_pass@fakeproxy.foo:8080"
+      end
+
+      {
+        :user => 'my_user',
+        :pass => 'my_pass',
+        :address => 'fakeproxy.foo',
+        :port => 8080
+      }.each do |var,expected|
+        it "for #{var}" do
+          vars[var].should == expected
+        end
+      end
+    end
+  end
+
+  context "Configuration file parsing" do
     it "should exit if config file can't be read" do
       ConfigHelper.write_out_config(ConfigHelper.global_config_path,
                                     "global.openshift.redhat.com",
@@ -325,6 +351,6 @@ class ConfigHelper
       f.write("libra_server = #{server}\n") unless server.nil?
       f.write("default_rhlogin = #{login}\n\n") unless login.nil?
       other.each { |key, value| f.write("#{key}=#{value}\n") }
+    end
   end
 end
-end

data/spec/rhc/context_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require 'rhc/commands/base'
+require 'rhc/exceptions'
+
+describe RHC::Commands::Base do
+  context 'when statically defined with context' do
+    subject do
+      Kernel.module_eval do
+        class Static < RHC::Commands::Base
+          suppress_wizard
+
+          def one_context
+            1
+          end
+
+          def nil_context
+            nil
+          end
+
+          option ["--context-opt opt1"], "Test context option", :context => :one_context
+          summary "Test command execute with one_context"
+          def execute_with_one_context; return options.context_opt; end
+
+          option ["--context-opt opt1"], "Test context option", :context => :nil_context, :required => true
+          summary "Test command nil_context"
+          def execute_with_nil_context; return options.context_opt; end
+        end
+      end
+      Static
+    end
+
+    let(:instance) { subject.new }
+
+    context 'and when execute_with_one_context is called' do
+      it { expects_running('static', 'execute-with-one-context').should call(:one_context).on(instance).with(no_args) }
+      it { expects_running('static', 'execute-with-one-context').should exit_with_code(1)  }
+      it { expects_running('static', 'execute-with-one-context', '--context-opt', 'opt').should call(:execute_with_one_context).on(instance).with(no_args) }
+      it { expects_running('static', 'execute-with-one-context', '--context-opt', 'opt').should exit_with_code('opt')  }
+    end
+
+    context 'and when execute_with_nil_context is called' do
+      it { expects_running('static', 'execute-with-nil-context').should call(:nil_context).on(instance).with(no_args) }
+      it { expects_running('static', 'execute-with-nil-context', '--trace').should raise_error(ArgumentError)  }
+      it { expects_running('static', 'execute-with-nil-context', '--context-opt', 'opt', '--trace').should call(:execute_with_nil_context).on(instance).with(no_args) }
+      it { expects_running('static', 'execute-with-nil-context', '--context-opt', 'opt', '--trace').should exit_with_code('opt')  }
+    end
+  end
+end
+
+
+

data/spec/rhc/helpers_spec.rb

@@ -4,13 +4,14 @@ require 'rhc/ssh_key_helpers'
 require 'rhc/core_ext'
 require 'highline/import'
 require 'rhc/config'
+require 'rhc/helpers'
 require 'date'
 
 describe RHC::Helpers do
   before(:each) do
     mock_terminal
     RHC::Config.set_defaults
-    @tests = HelperTests.new()
+    @tests = HelperTests.new
   end
 
   subject do
@@ -47,6 +48,12 @@ describe RHC::Helpers do
     end.should == ['10 2','3  40']
   end
 
+  it("should generate table rows"){ subject.send(:make_table, [1,2]).should == [1,2] }
+  it("should generate a table"){ subject.send(:make_table, 1).should == [1] }
+  it("should output a table") do 
+    subject.send(:display_no_info, 'test').should == ['This test has no information to show']
+  end
+
   it "should parse an RFC3339 date" do
     d = subject.datetime_rfc3339('2012-06-24T20:48:20-04:00')
     d.day.should == 24
@@ -139,18 +146,12 @@ describe RHC::Helpers do
   end
 
   context "SSH Key Helpers" do
-    before do
-      FakeFS.activate!
-    end
-
     it "should generate an ssh key then return nil when it tries to create another" do
-      @tests.generate_ssh_key_ruby.should match("\.ssh/id_rsa\.pub")
-      @tests.generate_ssh_key_ruby == nil
-    end
-
-    after do
-      FakeFS::FileSystem.clear
-      FakeFS.deactivate!
+      FakeFS do
+        FakeFS::FileSystem.clear
+        @tests.generate_ssh_key_ruby.should match("\.ssh/id_rsa\.pub")
+        @tests.generate_ssh_key_ruby == nil
+      end
     end
   end
 
@@ -254,3 +255,42 @@ describe OpenURI do
     specify('https to http') { OpenURI.redirectable?(URI.parse('https://foo.com'), URI.parse('http://foo.com')).should be_false }
   end
 end
+
+describe HighLine do
+  it "should wrap the terminal" do
+    $terminal.wrap_at = 10
+    say "Lorem ipsum dolor sit amet"
+    output = $terminal.read
+    output.should match "Lorem\nipsum\ndolor sit\namet"
+  end
+  it "should wrap the terminal" do
+    $terminal.wrap_at = 16
+    say "Lorem ipsum dolor sit amet"
+    output = $terminal.read
+    output.should match "Lorem ipsum\ndolor sit amet"
+  end
+  it "should not wrap the terminal" do
+    $terminal.wrap_at = 50
+    say "Lorem ipsum dolor sit amet"
+    output = $terminal.read
+    output.should match "Lorem ipsum dolor sit amet"
+  end
+  it "should wrap the terminal when using color codes" do
+    $terminal.wrap_at = 10
+    say $terminal.color("Lorem ipsum dolor sit amet Lorem ipsum dolor sit amet", :red)
+    output = $terminal.read
+    output.should match "Lorem\nipsum\ndolor sit\namet Lorem\nipsum\ndolor sit\namet"
+  end
+  it "should wrap the terminal with other escape characters" do
+    $terminal.wrap_at = 10
+    say "Lorem ipsum dolor sit am\eet"
+    output = $terminal.read
+    output.should match "Lorem\nipsum\ndolor sit\nam\eet"
+  end
+  it "should wrap the terminal when words are smaller than wrap length" do
+    $terminal.wrap_at = 3
+    say "Antidisestablishmentarianism"
+    output = $terminal.read
+    output.should match "Ant\nidi\nses\ntab\nlis\nhme\nnta\nria\nnis\nm"
+  end
+end

data/spec/rhc/rest_application_spec.rb

@@ -30,7 +30,7 @@ module RHC
         it "returns an application object" do
           app = app_obj
           app.should be_an_instance_of RHC::Rest::Application
-          app.instance_variable_get(:@links).length.should equal(app_links.length)
+          app.send(:links).length.should equal(app_links.length)
         end
       end
 
@@ -43,7 +43,7 @@ module RHC
           app  = app_obj
           cart = app.add_cartridge('mock_cart_0')
           cart.should be_an_instance_of RHC::Rest::Cartridge
-          cart.instance_variable_get(:@name).should == 'mock_cart_0'
+          cart.name.should == 'mock_cart_0'
         end
       end
 
@@ -59,7 +59,7 @@ module RHC
           carts.length.should equal(2)
           (0..1).each do |idx|
             carts[idx].should be_an_instance_of RHC::Rest::Cartridge
-            carts[idx].instance_variable_get(:@name).should == "mock_cart_#{idx}"
+            carts[idx].name.should == "mock_cart_#{idx}"
           end
         end
         it "returns an empty list if the current app has no cartridges" do
@@ -70,6 +70,19 @@ module RHC
         end
       end
 
+      context "#gear_groups" do
+        before(:each) do
+          stub_api_request(:any, app_links['GET_GEAR_GROUPS']['relative']).
+            to_return(mock_gear_groups_response())
+        end
+        it "returns a list of all gear groups the current application" do
+          app   = app_obj
+          gear_groups = app.gear_groups
+          gear_groups.length.should equal(1)
+          gear_groups[0].should be_an_instance_of RHC::Rest::GearGroup
+        end
+      end
+
       # These application control tests are subtle; the key lies in making sure the
       # webmock specifies the expected body that is sent in the request.
       # This is currently of the form "event=foo"

data/spec/rhc/rest_client_spec.rb

@@ -14,8 +14,8 @@ class MockClient < RHC::Rest::Client
   def logger
     Logger.new((@output = StringIO.new))
   end
-  def debug
-    @mydebug = true
+  def use_debug
+    @debug = true
   end
   def logged
     @output.string
@@ -28,13 +28,14 @@ module RHC
       let(:client_links)   { mock_response_links(mock_client_links) }
       let(:domain_0_links) { mock_response_links(mock_domain_links('mock_domain_0')) }
       let(:domain_1_links) { mock_response_links(mock_domain_links('mock_domain_1')) }
+      let(:app_0_links)    { mock_response_links(mock_app_links('mock_domain_0', 'mock_app')) }
       let(:user_links)     { mock_response_links(mock_user_links) }
       let(:key_links)      { mock_response_links(mock_key_links) }
 
       context "#new" do
         before do
           stub_api_request(:get, '').
-            to_return({ :body   => { :data => client_links }.to_json,
+            to_return({ :body   => { :data => client_links, :supported_api_versions => [1.0, 1.1] }.to_json,
                         :status => 200
                       })
           stub_api_request(:get, 'api_error').
@@ -47,7 +48,7 @@ module RHC
           credentials = Base64.strict_encode64(mock_user + ":" + mock_pass)
           client      = RHC::Rest::Client.new(mock_href, mock_user, mock_pass)
           @@headers['Authorization'].should == "Basic #{credentials}"
-          client.instance_variable_get(:@links).should == client_links
+          client.send(:links).should == client_links
         end
         it "does not add newlines to username and password > 60 characters" do
           username = "a" * 45
@@ -60,14 +61,68 @@ module RHC
         end
         it "raises a generic error for any other error condition" do
           lambda{ RHC::Rest::Client.new(mock_href('other_error'), mock_user, mock_pass) }.
-            should raise_error("Resource could not be accessed:Other Error")
+            should raise_error("Failed to access resource: Other Error")
+        end
+      end
+      
+      describe "#new" do
+        context "when server supports API versions [1.0, 1.1]" do
+          before :each do
+            stub_api_request(:get, '').
+              to_return({ :body   => { :data => client_links, :supported_api_versions => [1.0, 1.1] }.to_json,
+                          :status => 200
+                        })
+            stub_api_request(:get, 'api_error').
+              to_raise(RestClient::ExceptionWithResponse.new('API Error'))
+            stub_api_request(:get, 'other_error').
+              to_raise(Exception.new('Other Error'))
+          end
+          
+          context "when client is instantiated with [1.0, 1.1] as the preferred API versions" do
+            before :each do
+              @client = RHC::Rest::Client.new(mock_href, mock_user, mock_pass, false, [1.0, 1.1])
+            end
+            it "settles on 1.1 as the API version" do
+              @client.api_version_negotiated.should == 1.1
+            end
+          end
+          
+          context "when client is instantiated with [1.1, 1.0] as the preferred API versions" do
+            before :each do
+              @client = RHC::Rest::Client.new(mock_href, mock_user, mock_pass, false, [1.1, 1.0])
+            end
+            it "settles on 1.0 as the API version" do
+              @client.api_version_negotiated.should == 1.0
+            end
+          end
+          
+          context "when client is instantiated with [1.2, 1.3] as the preferred API versions" do
+            before :each do
+              @client = RHC::Rest::Client.new(mock_href, mock_user, mock_pass, false, [1.2, 1.3])
+            end
+            it "fails to negotiate an agreeable API version" do
+              @client.api_version_negotiated.should be_nil
+            end
+          end
+          
+          context "when client is instantiated with [1.1, 1.0, 1.3] as the preferred API versions" do
+            before :each do
+              @client = RHC::Rest::Client.new(mock_href, mock_user, mock_pass, false, [1.1, 1.0, 1.3])
+            end
+            it "settles on 1.0 as the API version" do
+              @client.api_version_negotiated.should == 1.0
+            end
+          end
         end
       end
 
       context "with an instantiated client " do
         before(:each) do
           stub_api_request(:get, '').
-            to_return({ :body   => { :data => client_links }.to_json,
+            to_return({ :body   => {
+                          :data => client_links,
+                          :supported_api_versions => [1.0, 1.1]
+                        }.to_json,
                         :status => 200
                       })
           @client = RHC::Rest::Client.new(mock_href, mock_user, mock_pass)
@@ -78,6 +133,7 @@ module RHC
             stub_api_request(:any, client_links['ADD_DOMAIN']['relative']).
               to_return({ :body   => {
                             :type => 'domain',
+                            :supported_api_versions => [1.0, 1.1],
                             :data => {
                               :id    => 'mock_domain',
                               :links => mock_response_links(mock_domain_links('mock_domain')),
@@ -88,9 +144,9 @@ module RHC
           end
           it "returns a domain object" do
             domain = @client.add_domain('mock_domain')
-            domain.class.should                          == RHC::Rest::Domain
-            domain.instance_variable_get(:@id).should    == 'mock_domain'
-            domain.instance_variable_get(:@links).should ==
+            domain.class.should == RHC::Rest::Domain
+            domain.id.should == 'mock_domain'
+            domain.send(:links).should ==
               mock_response_links(mock_domain_links('mock_domain'))
           end
         end
@@ -122,8 +178,8 @@ module RHC
             domains.length.should equal(2)
             (0..1).each do |idx|
               domains[idx].class.should                          == RHC::Rest::Domain
-              domains[idx].instance_variable_get(:@id).should    == "mock_domain_#{idx}"
-              domains[idx].instance_variable_get(:@links).should ==
+              domains[idx].id.should    == "mock_domain_#{idx}"
+              domains[idx].send(:links).should ==
                 mock_response_links(mock_domain_links("mock_domain_#{idx}"))
             end
           end
@@ -214,9 +270,9 @@ module RHC
             domain.applications.each do |app|
               match = domain.find_application(app.name)
               match.class.should                              == RHC::Rest::Application
-              match.instance_variable_get(:@name).should      == 'mock_app'
-              match.instance_variable_get(:@domain_id).should == "#{domain.id}"
-              match.instance_variable_get(:@links).should     ==
+              match.name.should      == 'mock_app'
+              match.domain_id.should == "#{domain.id}"
+              match.send(:links).should     ==
                 mock_response_links(mock_app_links("#{domain.id}",'mock_app'))
             end
           end
@@ -254,9 +310,9 @@ module RHC
             carts.length.should equal(2)
             (0..1).each do |idx|
               carts[idx].class.should                          == RHC::Rest::Cartridge
-              carts[idx].instance_variable_get(:@name).should  == "mock_cart_#{idx}"
-              carts[idx].instance_variable_get(:@type).should  == "mock_cart_#{idx}_type"
-              carts[idx].instance_variable_get(:@links).should ==
+              carts[idx].name.should  == "mock_cart_#{idx}"
+              carts[idx].type.should  == "mock_cart_#{idx}_type"
+              carts[idx].send(:links).should ==
                 mock_response_links(mock_cart_links("mock_cart_#{idx}"))
             end
           end
@@ -295,9 +351,9 @@ module RHC
             matches = @client.find_cartridges('mock_cart_0')
             matches.length.should equal(1)
             matches[0].class.should                          == RHC::Rest::Cartridge
-            matches[0].instance_variable_get(:@name).should  == 'mock_cart_0'
-            matches[0].instance_variable_get(:@type).should  == 'mock_cart_0_type'
-            matches[0].instance_variable_get(:@links).should ==
+            matches[0].name.should  == 'mock_cart_0'
+            matches[0].type.should  == 'mock_cart_0_type'
+            matches[0].send(:links).should ==
               mock_response_links(mock_cart_links('mock_cart_0'))
           end
           it "returns an empty list when no matching cartridges can be found" do
@@ -326,8 +382,8 @@ module RHC
           it "returns the user object associated with this client connection" do
             user = @client.user
             user.class.should                           == RHC::Rest::User
-            user.instance_variable_get(:@login).should  == mock_user
-            user.instance_variable_get(:@links).should  == mock_response_links(mock_user_links)
+            user.login.should  == mock_user
+            user.send(:links).should  == mock_response_links(mock_user_links)
           end
         end
 
@@ -366,10 +422,10 @@ module RHC
             expect { key = @client.find_key('mock_key_0') }.should_not raise_error
 
             key.class.should                            == RHC::Rest::Key
-            key.instance_variable_get(:@name).should    == 'mock_key_0'
-            key.instance_variable_get(:@type).should    == 'mock_key_0_type'
-            key.instance_variable_get(:@content).should == '123456789:0'
-            key.instance_variable_get(:@links).should   ==
+            key.name.should    == 'mock_key_0'
+            key.type.should    == 'mock_key_0_type'
+            key.content.should == '123456789:0'
+            key.send(:links).should   ==
               mock_response_links(mock_key_links('mock_key_0'))
           end
           it "raise an error when no matching keys can be found" do
@@ -380,25 +436,28 @@ module RHC
         shared_examples_for "a logout method" do
           before(:each) do
             stub_api_request(:get, '').
-              to_return({ :body   => { :data => client_links }.to_json,
+              to_return({ :body   => { :data => client_links, :supported_api_versions => [1.0, 1.1] }.to_json,
                           :status => 200
                         })
-            @client = MockClient.new(mock_href, mock_user, mock_pass)
           end
           context "debug mode is on" do
             it "writes a message to the logger" do
-              @client.debug
-              @client.logger # starts our mock logger
-              eval '@client.' + logout_method.to_s
-              @client.logged.should =~ /Logout\/Close client$/
+              capture do
+                @client = MockClient.new(mock_href, mock_user, mock_pass, true)
+                @client.send logout_method.to_sym
+                $stderr.rewind
+                $stderr.read.should =~ /Logout\/Close client$/
+              end
             end
           end
           context "debug mode is off" do
             it "does nothing" do
-              @client = MockClient.new(mock_href, mock_user, mock_pass)
-              @client.logger # starts our mock logger
-              eval '@client.' + logout_method.to_s
-              @client.logged.should == ''
+              capture do
+                @client = MockClient.new(mock_href, mock_user, mock_pass, false)
+                @client.send logout_method.to_sym
+                $stderr.rewind
+                $stderr.read.should == ''
+              end
             end
           end
         end
@@ -461,6 +520,55 @@ module RHC
           it_should_behave_like "a logout method"
         end
       end
+        
+      context "when server supports API versions 1.0 and 1.1" do
+        before :each do
+          stub_api_request(:get, '').
+            to_return({ :body   => {
+                          :data => client_links,
+                          :supported_api_versions => [1.0, 1.1]
+                        }.to_json,
+                        :status => 200
+                      })
+        end
+        
+        context "when client supports API version 1.1" do
+          before :each do
+            @client = RHC::Rest::Client.new(mock_href, mock_user, mock_pass, false, [1.1])
+          end
+            
+          describe "#api_version_negotiated" do
+            it "returns 1.1" do
+              @client.api_version_negotiated.to_s.should == '1.1'
+            end
+          end
+        end
+          
+        context "when client supports only API version 1.2" do
+          before :each do
+            @client = RHC::Rest::Client.new(mock_href, mock_user, mock_pass, false, [1.2])
+          end
+            
+          describe "#api_version_negotiated" do
+            it 'returns nil' do
+              @client.api_version_negotiated.should be_nil
+            end
+          end
+        end
+        
+        context "when client supports only API version 0.9" do
+          describe "#new" do
+            it "warns user that it is outdated" do
+              capture do
+                @client = RHC::Rest::Client.new(mock_href, mock_user, mock_pass, false, [0.9])
+                @output.rewind
+                @output.read.should =~ /client version may be outdated/
+              end
+            end
+          end
+        end
+      end
+      
     end
   end
 end

data/spec/rhc/rest_spec.rb

@@ -55,7 +55,7 @@ module RHC
             :links           => { :foo => 'bar' }
           }}
         it "deserializes to an application" do
-          json_response = { :type => 'application', :data => object }.to_json
+          json_response = { :type => 'application', :data => object, :messages => [{'text' => 'test message'}]}.to_json
           app_obj       = RHC::Rest::Application.new(object)
           subject.parse_response(json_response).should have_same_attributes_as(app_obj)
         end