rhc 1.2.7 → 1.3.8

data/spec/rhc/rest_client_spec.rb

@@ -21,6 +21,18 @@ end
 module RHC
   module Rest
     describe Client do
+
+      let(:endpoint){ mock_href }
+      let(:username){ nil }# mock_user }
+      let(:password){ nil }# mock_pass }
+      let(:use_debug){ false }
+      #let(:spec_versions){ nil }
+      let(:client) do 
+        respond_to?(:spec_versions) ? 
+          RHC::Rest::Client.new(endpoint, username, password, use_debug, spec_versions) :
+          RHC::Rest::Client.new(endpoint, username, password, use_debug)
+      end
+
       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')) }
@@ -35,32 +47,29 @@ module RHC
                         :status => 200
                       })
           stub_api_request(:get, 'api_error').
-            to_raise(RestClient::ExceptionWithResponse.new('API Error'))
+            to_raise(HTTPClient::BadResponseError.new('API Error'))
           stub_api_request(:get, 'other_error').
-            to_raise(Exception.new('Other Error'))
+            to_raise(StandardError.new('Other Error'))
         end
 
         it "returns a client object from the required arguments" do
           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.send(:links).should == client_links
+          client.api.send(:links).should == client_links
         end
-        it "does not add newlines to username and password > 60 characters" do
-          username = "a" * 45
-          password = "p" * 45
-          client   = RHC::Rest::Client.new(mock_href, mock_user, mock_pass)
-          @@headers['Authorization'].should_not match("\n")
-        end
-        it "raises an error message if the API cannot be connected" do
-          expect { MockClient.new(mock_href('api_error'), mock_user, mock_pass) }.should raise_error
+        context "against an endpoint that won't connect" do
+          let(:endpoint){ mock_href('api_error') }
+          it "raises an error message" do
+            expect{ client.api }.should raise_error
+          end
         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("Failed to access resource: Other Error")
+        context "against an endpoint that has a generic error" do
+          let(:endpoint){ mock_href('other_error') }
+          it "raises a generic error for any other error condition" do
+            expect{ client.api }.should raise_error(RHC::Rest::ConnectionException, "An unexpected error occured: Other Error")
+          end
         end
       end
-      
+
       describe "#new" do
         context "when server supports API versions [1.0, 1.1]" do
           before :each do
@@ -69,44 +78,36 @@ module RHC
                           :status => 200
                         })
             stub_api_request(:get, 'api_error').
-              to_raise(RestClient::ExceptionWithResponse.new('API Error'))
+              to_raise(HTTPClient::BadResponseError.new('API Error'))
             stub_api_request(:get, 'other_error').
-              to_raise(Exception.new('Other Error'))
+              to_raise(StandardError.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
+            let(:spec_versions){ [1.0, 1.1] }
             it "settles on 1.1 as the API version" do
-              @client.api_version_negotiated.should == 1.1
+              client.api.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
+            let(:spec_versions){ [1.1, 1.0] }
             it "settles on 1.0 as the API version" do
-              @client.api_version_negotiated.should == 1.0
+              client.api.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
+            let(:spec_versions){ [1.2, 1.3] }
             it "fails to negotiate an agreeable API version" do
-              @client.api_version_negotiated.should be_nil
+              client.api.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
+            let(:spec_versions){ [1.1, 1.0, 1.3] }
             it "settles on 1.0 as the API version" do
-              @client.api_version_negotiated.should == 1.0
+              client.api.api_version_negotiated.should == 1.0
             end
           end
         end
@@ -121,7 +122,6 @@ module RHC
                         }.to_json,
                         :status => 200
                       })
-          @client = RHC::Rest::Client.new(mock_href, mock_user, mock_pass)
         end
 
         context "#add_domain" do
@@ -139,7 +139,7 @@ module RHC
                         })
           end
           it "returns a domain object" do
-            domain = @client.add_domain('mock_domain')
+            domain = client.add_domain('mock_domain')
             domain.class.should == RHC::Rest::Domain
             domain.id.should == 'mock_domain'
             domain.send(:links).should ==
@@ -170,10 +170,10 @@ module RHC
                         })
           end
           it "returns a list of existing domains" do
-            domains = @client.domains
+            domains = client.domains
             domains.length.should equal(2)
             (0..1).each do |idx|
-              domains[idx].class.should                          == RHC::Rest::Domain
+              domains[idx].class.should == RHC::Rest::Domain
               domains[idx].id.should    == "mock_domain_#{idx}"
               domains[idx].send(:links).should ==
                 mock_response_links(mock_domain_links("mock_domain_#{idx}"))
@@ -181,8 +181,9 @@ module RHC
           end
           it "returns an empty list when no domains exist" do
             # Disregard the first response; this is for the previous expectiation.
-            domains = @client.domains
-            domains = @client.domains
+            domains = client.domains
+            client.instance_variable_set(:@domains, nil)
+            domains = client.domains
             domains.length.should equal(0)
           end
         end
@@ -205,13 +206,13 @@ module RHC
           end
           it "returns a domain object for matching domain IDs" do
             match = nil
-            expect { match = @client.find_domain('mock_domain_0') }.should_not raise_error
+            expect { match = client.find_domain('mock_domain_0') }.should_not raise_error
 
             match.id.should == 'mock_domain_0'
             match.class.should == RHC::Rest::Domain
           end
           it "raise an error when no matching domain IDs can be found" do
-            expect { @client.find_domain('mock_domain_2') }.should raise_error(RHC::DomainNotFoundException)
+            expect { client.find_domain('mock_domain_2') }.should raise_error(RHC::DomainNotFoundException)
           end
         end
 
@@ -262,10 +263,10 @@ module RHC
                         })
           end
           it "returns application objects for matching application IDs" do
-            domain = @client.domains[0]
+            domain = client.domains[0]
             domain.applications.each do |app|
               match = domain.find_application(app.name)
-              match.class.should                              == RHC::Rest::Application
+              match.class.should     == RHC::Rest::Application
               match.name.should      == 'mock_app'
               match.domain_id.should == "#{domain.id}"
               match.send(:links).should     ==
@@ -273,7 +274,30 @@ module RHC
             end
           end
           it "Raises an excpetion when no matching applications can be found" do
-            expect { @client.domains[0].find_application('no_match') }.should raise_error(RHC::ApplicationNotFoundException)
+            expect { client.domains[0].find_application('no_match') }.should raise_error(RHC::ApplicationNotFoundException)
+          end
+        end
+
+        describe RHC::Rest::Cartridge do
+          subject do 
+            described_class.new({
+              :name => 'foo',
+              :links => mock_response_links([
+                ['GET', 'broker/rest/cartridge', 'get']
+              ])}, client)
+          end
+          context "when several messages are present" do
+            before do 
+              stub_api_request(:get, 'broker/rest/cartridge', true).
+                with(:query => {:include => :status_messages}).
+                to_return(:body => {
+                  :type => 'cartridge',
+                  :data => {
+                    :status_messages => [{:message => 'Test'}]
+                  }
+                }.to_json)
+            end
+            its(:status){ should == [{'message' => 'Test'}] }
           end
         end
 
@@ -302,21 +326,22 @@ module RHC
                         })
           end
           it "returns a list of existing cartridges" do 
-            carts = @client.cartridges
+            carts = client.cartridges
             carts.length.should equal(2)
             (0..1).each do |idx|
-              carts[idx].class.should                          == RHC::Rest::Cartridge
+              carts[idx].class.should == RHC::Rest::Cartridge
               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
-          it "returns an empty list when no cartridges exist" do
+          it "caches cartridges on the client" do
             # Disregard the first response; this is for the previous expectiation.
-            carts = @client.cartridges
-            carts = @client.cartridges
-            carts.length.should equal(0)
+            old = client.cartridges.length
+            client.cartridges.length.should equal(old)
+            client.instance_variable_set(:@cartridges, nil)
+            client.cartridges.length.should equal(0)
           end
         end
 
@@ -344,20 +369,20 @@ module RHC
                         })
           end
           it "returns a list of cartridge objects for matching cartridges" do
-            matches = @client.find_cartridges('mock_cart_0')
+            matches = client.find_cartridges('mock_cart_0')
             matches.length.should equal(1)
-            matches[0].class.should                          == RHC::Rest::Cartridge
+            matches[0].class.should == RHC::Rest::Cartridge
             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
-            matches = @client.find_cartridges('no_match')
+            matches = client.find_cartridges('no_match')
             matches.length.should equal(0)
           end
           it "returns multiple cartridge matches" do
-            matches = @client.find_cartridges :regex => "mock_cart_[0-9]"
+            matches = client.find_cartridges :regex => "mock_cart_[0-9]"
             matches.length.should equal(2)
           end
         end
@@ -376,8 +401,8 @@ module RHC
                         })
           end
           it "returns the user object associated with this client connection" do
-            user = @client.user
-            user.class.should                           == RHC::Rest::User
+            user = client.user
+            user.class.should  == RHC::Rest::User
             user.login.should  == mock_user
             user.send(:links).should  == mock_response_links(mock_user_links)
           end
@@ -415,9 +440,9 @@ module RHC
           end
           it "returns a list of key objects for matching keys" do
             key = nil
-            expect { key = @client.find_key('mock_key_0') }.should_not raise_error
+            expect { key = client.find_key('mock_key_0') }.should_not raise_error
 
-            key.class.should                            == RHC::Rest::Key
+            key.class.should   == RHC::Rest::Key
             key.name.should    == 'mock_key_0'
             key.type.should    == 'mock_key_0_type'
             key.content.should == '123456789:0'
@@ -425,7 +450,7 @@ module RHC
               mock_response_links(mock_key_links('mock_key_0'))
           end
           it "raise an error when no matching keys can be found" do
-            expect { @client.find_key('no_match') }.should raise_error(RHC::KeyNotFoundException)
+            expect { client.find_key('no_match') }.should raise_error(RHC::KeyNotFoundException)
           end
         end
 
@@ -437,11 +462,10 @@ module RHC
                         })
           end
           context "debug mode is on" do
+            let(:use_debug){ true }
             it "writes a message to the logger" do
               capture do
-                @client = MockClient.new(mock_href, mock_user, mock_pass, true)
-                @client.send logout_method.to_sym
-
+                client.send logout_method.to_sym
                 stderr.should match(/Logout\/Close client$/)
               end
             end
@@ -449,8 +473,7 @@ module RHC
           context "debug mode is off" do
             it "does nothing" do
               capture do
-                @client = MockClient.new(mock_href, mock_user, mock_pass, false)
-                @client.send logout_method.to_sym
+                client.send logout_method.to_sym
                 stderr.should be_empty
               end
             end
@@ -491,20 +514,18 @@ module RHC
               to_return({ :body   => {}.to_json,
                           :status => 200
                         })
-
-            @client = MockClient.new(mock_href, mock_user, mock_pass)
           end
-          
+
           it "should delete keys" do
-            expect { @client.delete_key('mock_key_0') }.should be_true
+            expect { client.delete_key('mock_key_0') }.should be_true
           end
-          
+
           it 'raises an error if nonexistent key is requested' do
-            expect { @client.find_key('no_match') }.
+            expect { client.find_key('no_match') }.
               should raise_error(RHC::KeyNotFoundException)
           end
         end
-        
+
         context "#logout" do
           let(:logout_method) { :logout }
           it_should_behave_like "a logout method"
@@ -515,7 +536,7 @@ 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, '').
@@ -526,36 +547,33 @@ module RHC
                         :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
-            
+          let(:spec_versions){ [1.1] }
+
           describe "#api_version_negotiated" do
             it "returns 1.1" do
-              @client.api_version_negotiated.to_s.should == '1.1'
+              client.api.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
-            
+          let(:spec_versions){ [1.2] }
+
           describe "#api_version_negotiated" do
             it 'returns nil' do
-              @client.api_version_negotiated.should be_nil
+              client.api.api_version_negotiated.should be_nil
             end
           end
         end
-        
+
         context "when client supports only API version 0.9" do
           describe "#new" do
+            let(:spec_versions){ [0.9] }
             it "warns user that it is outdated" do
               capture do
-                @client = RHC::Rest::Client.new(mock_href, mock_user, mock_pass, false, [0.9])
+                client.api
                 @output.rewind
                 @output.read.should =~ /client version may be outdated/
               end
@@ -563,7 +581,6 @@ module RHC
           end
         end
       end
-      
     end
   end
 end

data/spec/rhc/rest_spec.rb

@@ -7,7 +7,7 @@ class RHCRest
   def debug?
     false
   end
-  def debug
+  def debug(*args)
     raise "Unchecked debug"
   end
 end
@@ -16,17 +16,53 @@ module MockRestResponse
   attr_accessor :code, :read
 end
 
+
+describe RHC::Rest::Cartridge do
+  context 'with a name' do
+    before{ subject.name = 'foo' }
+    its(:display_name){ should == 'foo' }
+
+    context 'when display name is present' do
+      before{ subject.display_name = 'bar' }
+      its(:display_name){ should == 'bar' }
+    end
+  end
+end
+
 module RHC
 
   describe Rest do
-    subject{ RHCRest.new }
+    subject{ RHC::Rest::Client.new }
 
     # logger function
     describe "#logger" do
       it "establishes a logger" do
         logger = Logger.new(STDOUT)
-        subject.logger.should have_same_attributes_as(logger)
+        subject.send(:logger).should have_same_attributes_as(logger)
+      end
+      it "reuses a logger" do
+        subject.send(:logger).should equal(subject.send(:logger))
+      end
+    end
+
+    describe "#default_verify_callback" do
+      def invoked_with(is_ok, ctx)
+        subject.send(:default_verify_callback).call(is_ok, ctx)
       end
+      it{ invoked_with(true, nil).should be_true }
+
+      it{ expect{ invoked_with(false, nil) }.to raise_error(NoMethodError) }
+
+      context "with a self signed cert" do
+        it{ invoked_with(false, stub(:current_cert => stub(:issuer => '1', :subject => stub(:cmp => 0)))).should be_false }
+        after{ subject.send(:self_signed?).should be_true }
+      end
+
+      context "with an intermediate signed cert" do
+        it{ invoked_with(false, stub(:current_cert => stub(:issuer => '2', :subject => stub(:cmp => 1)), :error => 1, :error_string => 'a')).should be_false }
+        after{ subject.send(:self_signed?).should be_false }
+      end
+
     end
 
     # parse_response function
@@ -35,7 +71,7 @@ module RHC
         let(:object) {{ :links => { :foo => 'bar' } }}
         it "deserializes to the encapsulated data" do
           json_response = { :data => object }.to_json
-          subject.parse_response(json_response).should have_same_attributes_as(object)
+          subject.send(:parse_response, json_response).should have_same_attributes_as(object)
         end
       end
 
@@ -52,7 +88,7 @@ module RHC
         it "deserializes to an application" do
           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)
+          subject.send(:parse_response, json_response).should have_same_attributes_as(app_obj)
         end
       end
 
@@ -78,9 +114,9 @@ module RHC
           json_response = { :type => 'applications', :data => object }.to_json
           app_obj_1     = RHC::Rest::Application.new(object[0])
           app_obj_2     = RHC::Rest::Application.new(object[1])
-          subject.parse_response(json_response).length.should equal(2)
-          subject.parse_response(json_response)[0].should have_same_attributes_as(app_obj_1)
-          subject.parse_response(json_response)[1].should have_same_attributes_as(app_obj_2)
+          subject.send(:parse_response, json_response).length.should equal(2)
+          subject.send(:parse_response, json_response)[0].should have_same_attributes_as(app_obj_1)
+          subject.send(:parse_response, json_response)[1].should have_same_attributes_as(app_obj_2)
         end
       end
 
@@ -94,7 +130,7 @@ module RHC
         it "deserializes to a cartridge" do
           json_response = { :type => 'cartridge', :data => object }.to_json
           cart_obj      = RHC::Rest::Cartridge.new(object)
-          subject.parse_response(json_response).should have_same_attributes_as(cart_obj)
+          subject.send(:parse_response, json_response).should have_same_attributes_as(cart_obj)
         end
       end
 
@@ -113,9 +149,9 @@ module RHC
           json_response = { :type => 'cartridges', :data => object }.to_json
           cart_obj_1    = RHC::Rest::Cartridge.new(object[0])
           cart_obj_2    = RHC::Rest::Cartridge.new(object[1])
-          subject.parse_response(json_response).length.should equal(2)
-          subject.parse_response(json_response)[0].should have_same_attributes_as(cart_obj_1)
-          subject.parse_response(json_response)[1].should have_same_attributes_as(cart_obj_2)
+          subject.send(:parse_response, json_response).length.should equal(2)
+          subject.send(:parse_response, json_response)[0].should have_same_attributes_as(cart_obj_1)
+          subject.send(:parse_response, json_response)[1].should have_same_attributes_as(cart_obj_2)
         end
       end
 
@@ -128,7 +164,7 @@ module RHC
         it "deserializes to a domain" do
           json_response = { :type => 'domain', :data => object }.to_json
           dom_obj       = RHC::Rest::Domain.new(object)
-          subject.parse_response(json_response).should have_same_attributes_as(dom_obj)
+          subject.send(:parse_response, json_response).should have_same_attributes_as(dom_obj)
         end
       end
 
@@ -145,9 +181,9 @@ module RHC
           json_response = { :type => 'domains', :data => object }.to_json
           dom_obj_1     = RHC::Rest::Domain.new(object[0])
           dom_obj_2     = RHC::Rest::Domain.new(object[1])
-          subject.parse_response(json_response).length.should equal(2)
-          subject.parse_response(json_response)[0].should have_same_attributes_as(dom_obj_1)
-          subject.parse_response(json_response)[1].should have_same_attributes_as(dom_obj_2)
+          subject.send(:parse_response, json_response).length.should equal(2)
+          subject.send(:parse_response, json_response)[0].should have_same_attributes_as(dom_obj_1)
+          subject.send(:parse_response, json_response)[1].should have_same_attributes_as(dom_obj_2)
         end
       end
 
@@ -162,7 +198,7 @@ module RHC
         it "deserializes to a key" do
           json_response = { :type => 'key', :data => object }.to_json
           key_obj       = RHC::Rest::Key.new(object)
-          subject.parse_response(json_response).should have_same_attributes_as(key_obj)
+          subject.send(:parse_response, json_response).should have_same_attributes_as(key_obj)
         end
       end
 
@@ -183,9 +219,9 @@ module RHC
           json_response = { :type => 'keys', :data => object }.to_json
           key_obj_1     = RHC::Rest::Key.new(object[0])
           key_obj_2     = RHC::Rest::Key.new(object[1])
-          subject.parse_response(json_response).length.should equal(2)
-          subject.parse_response(json_response)[0].should have_same_attributes_as(key_obj_1)
-          subject.parse_response(json_response)[1].should have_same_attributes_as(key_obj_2)
+          subject.send(:parse_response, json_response).length.should equal(2)
+          subject.send(:parse_response, json_response)[0].should have_same_attributes_as(key_obj_1)
+          subject.send(:parse_response, json_response)[1].should have_same_attributes_as(key_obj_2)
         end
       end
 
@@ -198,13 +234,26 @@ module RHC
         it "deserializes to a user" do
           json_response = { :type => 'user', :data => object }.to_json
           user_obj      = RHC::Rest::User.new(object)
-          subject.parse_response(json_response).should have_same_attributes_as(user_obj)
+          subject.send(:parse_response, json_response).should have_same_attributes_as(user_obj)
         end
       end
     end
 
     # request function
     describe "#request" do
+      let(:response){ lambda { subject.request(request) } }
+      let(:request){ {:url => mock_href, :method  => method, :headers => {:accept => :json} } }
+      let(:method){ :get }
+
+      if HTTPClient::SSLConfig.method_defined? :ssl_version
+        context "when an invalid ssl version is passed, OpenSSL should reject us" do
+          let(:request){ {:url => "https://openshift.redhat.com", :method => :get, :ssl_version => :SSLv3_server} }
+          before{ WebMock.allow_net_connect! }
+          it("fails to call openssl"){ response.should raise_error(RHC::Rest::SSLConnectionFailed, /called a function you should not call/) }
+          after{ WebMock.disable_net_connect! }
+        end
+      end
+
       context "with a successful request" do
         let(:object) {{
             :type => 'domain',
@@ -223,13 +272,7 @@ module RHC
 
         it "sends the response to be deserialized" do
           dom_obj = RHC::Rest::Domain.new(object)
-          request = RestClient::Request.new(:url     => mock_href,
-                                            :method  => 'get',
-                                            :headers => { :accept => :json },
-                                            :payload => {},
-                                            :timeout => 300
-                                            )
-          subject.request(request).should have_same_attributes_as(dom_obj)
+          subject.request(request.merge(:payload => {}, :timeout => 300)).should have_same_attributes_as(dom_obj)
         end
       end
 
@@ -243,11 +286,7 @@ module RHC
           stub_request(:get, mock_href).to_return(return_data)
         end
         it "throws an error" do
-          request = RestClient::Request.new(:url     => mock_href,
-                                            :method  => 'get',
-                                            :headers => {:accept => :json}
-                                            )
-          lambda { subject.request(request) }.should raise_error(RHC::Rest::ResourceAccessException, 'Failed to access resource: unexpected nil')
+          response.should raise_error(RHC::Rest::ConnectionException, 'An unexpected error occured: unexpected nil')
         end
       end
 
@@ -261,95 +300,103 @@ module RHC
           stub_request(:get, mock_href).to_return(return_data)
         end
         it "quietly exits" do
-          request = RestClient::Request.new(:url     => mock_href,
-                                            :method  => 'get',
-                                            :headers => {:accept => :json}
-                                            )
-          subject.request(request).should equal(nil)
+          response.call.should equal(nil)
         end
       end
 
       context "with a 502 (Bad Gateway) error" do
         before{ stub_request(method, mock_href).to_return(:status => 502) }
-        let(:req){ RestClient::Request.new(:url => mock_href, :method => method) }
-        let(:method){ :get }
 
-        it("should make two requests"){ subject.request(req) rescue nil; WebMock.should have_requested(method, mock_href).twice }
-        it{ expect{ subject.request(req) }.should raise_error(RHC::Rest::ConnectionException, /communicating with the server.*temporary/i) }
+        context "on a GET request" do
+          it("repeats the call"){ response.should raise_error(RHC::Rest::ConnectionException, /communicating with the server.*temporary/i) }
+          after{ WebMock.should have_requested(method, mock_href).twice }
+        end
 
         context "on a POST request" do
           let(:method){ :post }
 
-          it("should make one request"){ subject.request(req) rescue nil; WebMock.should have_requested(method, mock_href).once }
-          it{ expect{ subject.request(req) }.should raise_error(RHC::Rest::ConnectionException, /communicating with the server.*temporary/i) }
+          it("does not repeat the call"){ response.should raise_error(RHC::Rest::ConnectionException, /communicating with the server.*temporary/i) }
+          after{ WebMock.should have_requested(method, mock_href).once }
         end
       end
 
-      context "with a request timeout" do
-        before do
-          stub_request(:get, mock_href).to_timeout
+      context "with a GET request" do
+        it "serializes payload as query parameters" do
+          stub_request(:get, mock_href).with(:query => {:test => 1, :bar => 2}).to_return(:status => 204)
+          subject.request(request.merge(:payload => {:test => '1', :bar => 2})).should be_nil
         end
-        it "raises a resource access exception error" do
-          request = RestClient::Request.new(:url     => mock_href,
-                                            :method  => 'get',
-                                            :headers => {:accept => :json}
-                                            )
-          lambda { subject.request(request) }.should raise_error(RHC::Rest::TimeoutException, /Connection to server timed out. It is possible/)
+      end
+      context "with a POST request" do
+        let(:method){ :post }
+        it "serializes payload as urlencoded body parameters" do
+          stub_request(method, mock_href).
+            with(:headers => {:accept => 'application/json', :content_type => 'application/json'}, 
+                 :body => {:test => '1', :bar => 2}.to_json).
+            to_return(:status => 204)
+          subject.request(request.merge(:payload => {:test => '1', :bar => 2})).should be_nil
         end
       end
 
+      context "with a request timeout" do
+        before{ stub_request(:get, mock_href).to_timeout }
+        it{ response.should raise_error(RHC::Rest::TimeoutException, /Connection to server timed out. It is possible/) }
+      end
+
       context "with a broken server connection" do
+        before{ stub_request(:get, mock_href).to_raise(EOFError.new('Lost Server Connection')) }
+        it{ response.should raise_error(RHC::Rest::ConnectionException, 'Connection to server got interrupted: Lost Server Connection') }
+      end
+
+      #FIXME: the type of this exception should be a subclass of CertificateValidationFailed
+      context "with a potentially missing cert store" do
+        before{ stub_request(:get, mock_href).to_raise(OpenSSL::SSL::SSLError.new('unable to get local issuer certificate')) }
+        it{ response.should raise_error(RHC::Rest::SSLConnectionFailed, /You may need to specify your system CA certificate file/) }
+      end
+
+      context "with a self-signed SSL certificate" do
         before do
-          stub_request(:get, mock_href).to_raise(RestClient::ServerBrokeConnection.new('Lost Server Connection'))
-        end
-        it "raises a resource access exception error" do
-          request = RestClient::Request.new(:url     => mock_href,
-                                            :method  => 'get',
-                                            :headers => {:accept => :json}
-                                            )
-          lambda { subject.request(request) }.should raise_error(RHC::Rest::ConnectionException, 'Connection to server got interrupted: Lost Server Connection')
+          subject.should_receive(:self_signed?).and_return(true)
+          stub_request(:get, mock_href).to_raise(OpenSSL::SSL::SSLError.new('Unverified SSL Certificate'))
         end
+        it{ response.should raise_error(RHC::Rest::CertificateVerificationFailed, /The server is using a self-signed certificate/) }
       end
 
       context "with an unverified SSL certificate" do
-        before do
-          stub_request(:get, mock_href).to_raise(RestClient::SSLCertificateNotVerified.new('Unverified SSL Certificate'))
-        end
-        it "raises a resource access exception error" do
-          request = RestClient::Request.new(:url     => mock_href,
-                                            :method  => 'get',
-                                            :headers => {:accept => :json}
-                                            )
-          lambda { subject.request(request) }.should raise_error(RHC::Rest::ResourceAccessException, 'Failed to access resource: Unverified SSL Certificate')
-        end
+        before{ stub_request(:get, mock_href).to_raise(OpenSSL::SSL::SSLError.new('self signed certificate')) }
+        it{ response.should raise_error(RHC::Rest::CertificateVerificationFailed, /The server is using a self-signed certificate/) }
       end
 
-      context "with a socket errort" do
+      context "with an failed SSL certificate verification" do
+        before{ stub_request(:get, mock_href).to_raise(OpenSSL::SSL::SSLError.new('certificate verify failed')) }
+        it{ response.should raise_error(RHC::Rest::CertificateVerificationFailed, /The server's certificate could not be verified.*test\.domain\.com/) }
+      end
+
+      context "with a socket error" do
         before{ stub_request(:get, mock_href).to_raise(SocketError) }
-        it "raises a resource access exception error" do
-          request = RestClient::Request.new(:url     => mock_href,
-                                            :method  => 'get',
-                                            :headers => {:accept => :json}
-                                            )
-          lambda { subject.request(request) }.should raise_error(RHC::Rest::ConnectionException, /unable to connect to the server/i)
-        end
+        it{ response.should raise_error(RHC::Rest::ConnectionException, /unable to connect to the server/i) }
       end
 
-      context "with a generic exception error" do
-        before do
-          stub_request(:get, mock_href).to_raise(Exception.new('Generic Error'))
-        end
+      context "with an SSL connection error" do
+        before{ stub_request(:get, mock_href).to_raise(OpenSSL::SSL::SSLError) }
+        it{ response.should raise_error(RHC::Rest::SSLConnectionFailed, /a secure connection could not be established/i) }
+      end
 
-        it "raises a resource access exception error" do
-          request = RestClient::Request.new(:url     => mock_href,
-                                            :method  => 'get',
-                                            :headers => {:accept => :json}
-                                            )
-          lambda { subject.request(request) }.should raise_error(RHC::Rest::ResourceAccessException, 'Failed to access resource: Generic Error')
-        end
+      context "with an SSL certificate error" do
+        before{ stub_request(:get, mock_href).to_raise(OpenSSL::SSL::SSLError.new('certificate verify failed')) }
+        it{ response.should raise_error(RHC::Rest::CertificateVerificationFailed, /the server's certificate could not be verified/i) }
+      end
+
+      context "with an SSL version exception" do
+        before{ stub_request(:get, mock_href).to_raise(OpenSSL::SSL::SSLError.new('SSL_connect returned=1 errno=0 state=SSLv2/v3 read server hello A')) }
+        it{ response.should raise_error(RHC::Rest::SSLVersionRejected, /connection attempt with an older ssl protocol/i) }
       end
 
-      context "with a specific error response" do
+      context "with a generic exception error" do
+        before{ stub_request(:get, mock_href).to_raise(Exception.new('Generic Error')) }
+        it{ response.should raise_error(RHC::Rest::ConnectionException, "An unexpected error occured: Generic Error") }
+      end
+
+      context "with a an unauthorized request" do
         before do
           return_data = {
             :body    => nil,
@@ -358,40 +405,32 @@ module RHC
           }
           stub_request(:get, mock_href).to_return(return_data)
         end
-
-        it "passes the response off for interpretation" do
-          request = RestClient::Request.new(:url     => mock_href,
-                                            :method  => 'get',
-                                            :headers => {:accept => :json}
-                                            )
-          lambda { subject.request(request) }.should raise_error(RHC::Rest::UnAuthorizedException, 'Not authenticated')
-        end
+        it("raises not authenticated"){ response.should raise_error(RHC::Rest::UnAuthorizedException, 'Not authenticated') }
       end
     end
 
-    # process_error_response function
-    describe "#process_error_response" do
+    # handle_error! function
+    describe "#handle_error!" do
       let(:json){ nil }
       let(:body){ "<html><body>Something failed</body></html>" }
       let(:code){ nil }
+      let(:client){ HTTPClient.new(:proxy => proxy) }
+      let(:url){ "http://fake.url" }
+      let(:proxy){ nil }
       def response
-        (response = {}).extend(MockRestResponse)
-        response.code = code
-        response.read = json ? RHC::Json.encode(json) : body
-        response
+        mock(:status => code, :content => json ? RHC::Json.encode(json) : body)
       end
+      let(:method) { lambda{ subject.send(:handle_error!, response, url, client) } }
 
       context "with a 400 response" do
         let(:code){ 400 }
 
-        it "raises a generic server error" do
-          lambda { subject.process_error_response(response) }.should raise_error(RHC::Rest::ServerErrorException)
-        end
+        it{ method.should raise_error(RHC::Rest::ServerErrorException) }
 
         context "with a formatted JSON response" do
           let(:json){ {:messages => [{ :severity => 'error', :text => 'mock error message' }] } }
           it "raises a client error" do
-            lambda { subject.process_error_response(response) }.should raise_error(RHC::Rest::ClientErrorException, 'mock error message')
+            method.should raise_error(RHC::Rest::ClientErrorException, 'mock error message')
           end
         end
       end
@@ -400,7 +439,7 @@ module RHC
         let(:code){ 401 }
         let(:json){ {} }
         it "raises an 'unauthorized exception' error" do
-          lambda { subject.process_error_response(response) }.should raise_error(RHC::Rest::UnAuthorizedException, 'Not authenticated')
+          method.should raise_error(RHC::Rest::UnAuthorizedException, 'Not authenticated')
         end
       end
 
@@ -408,13 +447,13 @@ module RHC
         let(:code){ 403 }
 
         it "raises a request denied error" do
-          lambda { subject.process_error_response(response) }.should raise_error(RHC::Rest::RequestDeniedException)
+          method.should raise_error(RHC::Rest::RequestDeniedException)
         end
 
         context "with a formatted JSON response" do
           let(:json){ { :messages => [{ :severity => 'error', :text => 'mock error message' }] } }
           it "raises a 'request denied' error" do
-            lambda { subject.process_error_response(response) }.should raise_error(RHC::Rest::RequestDeniedException, 'mock error message')
+            method.should raise_error(RHC::Rest::RequestDeniedException, 'mock error message')
           end
         end
       end
@@ -423,13 +462,13 @@ module RHC
         let(:code){ 404 }
 
         it "raises a Not Found error" do
-          lambda { subject.process_error_response(response) }.should raise_error(RHC::Rest::ResourceNotFoundException)
+          method.should raise_error(RHC::Rest::ResourceNotFoundException)
         end
 
         context "with a formatted JSON response" do
           let(:json){ { :messages => [{ :severity => 'error', :text => 'mock error message' }] } }
           it "raises a 'resource not found' error" do
-            lambda { subject.process_error_response(response) }.should raise_error(RHC::Rest::ResourceNotFoundException, 'mock error message')
+            method.should raise_error(RHC::Rest::ResourceNotFoundException, 'mock error message')
           end
         end
       end
@@ -438,13 +477,45 @@ module RHC
         let(:code){ 409 }
 
         it "raises a generic server error" do
-          lambda { subject.process_error_response(response) }.should raise_error(RHC::Rest::ServerErrorException)
+          method.should raise_error(RHC::Rest::ServerErrorException)
         end
 
         context "with a formatted JSON response" do
           let(:json){ { :messages => [{ :severity => 'error', :text => 'mock error message' }] } }
           it "raises a validation error" do
-            lambda { subject.process_error_response(response) }.should raise_error(RHC::Rest::ValidationException, 'mock error message')
+            method.should raise_error(RHC::Rest::ValidationException, 'mock error message')
+          end
+        end
+        context "with multiple JSON messages" do
+          let(:json){ { :messages => [{ :field => 'error', :text => 'mock error message 1' },
+                                       { :field => 'error', :text => 'mock error message 2' }] } }
+          it "raises a validation error with concatenated messages" do
+            method.should raise_error(RHC::Rest::ValidationException, "The operation did not complete successfully, but the server returned additional information:\n* mock error message 1\n* mock error message 2")
+          end
+        end
+        context "with multiple errors" do
+          let(:json){ { :messages => [
+                          { :severity => 'error', :field => 'error', :text => 'mock 1' },
+                          { :severity => 'error', :text => 'mock 2' },
+                        ] } }
+          it "raises a validation error with concatenated messages" do
+            method.should raise_error(RHC::Rest::ValidationException, "The server reported multiple errors:\n* mock 1\n* mock 2")
+          end
+        end
+        context "with multiple messages and one error" do
+          let(:json){ { :messages => [
+                          { :field => 'error', :text => 'mock 1' },
+                          { :text => 'mock 2' },
+                          { :severity => 'error', :text => 'mock 3' },
+                        ] } }
+          it "raises a validation error with concatenated messages" do
+            method.should raise_error(RHC::Rest::ValidationException, "mock 3")
+          end
+        end
+        context "with an empty JSON response" do
+          let(:json){ {} }
+          it "raises a validation error" do
+            method.should raise_error(RHC::Rest::ServerErrorException)
           end
         end
       end
@@ -453,20 +524,20 @@ module RHC
         let(:code){ 422 }
 
         it "raises a generic server error" do
-          lambda { subject.process_error_response(response) }.should raise_error(RHC::Rest::ServerErrorException)
+          method.should raise_error(RHC::Rest::ServerErrorException)
         end
 
         context "with a single JSON message" do
           let(:json){ { :messages => [{ :severity => 'error', :text => 'mock error message' }] } }
           it "raises a validation error" do
-            lambda { subject.process_error_response(response) }.should raise_error(RHC::Rest::ValidationException, 'mock error message')
+            method.should raise_error(RHC::Rest::ValidationException, 'mock error message')
           end
         end
 
         context "with an empty JSON response" do
           let(:json){ {} }
           it "raises a validation error" do
-            lambda { subject.process_error_response(response) }.should raise_error(RHC::Rest::ValidationException, 'Not valid')
+            method.should raise_error(RHC::Rest::ServerErrorException)
           end
         end
 
@@ -474,7 +545,26 @@ module RHC
           let(:json){ { :messages => [{ :field => 'error', :text => 'mock error message 1' },
                                        { :field => 'error', :text => 'mock error message 2' }] } }
           it "raises a validation error with concatenated messages" do
-            lambda { subject.process_error_response(response) }.should raise_error(RHC::Rest::ValidationException, 'mock error message 1 mock error message 2')
+            method.should raise_error(RHC::Rest::ValidationException, "The operation did not complete successfully, but the server returned additional information:\n* mock error message 1\n* mock error message 2")
+          end
+        end
+        context "with multiple errors" do
+          let(:json){ { :messages => [
+                          { :severity => 'error', :field => 'error', :text => 'mock 1' },
+                          { :severity => 'error', :text => 'mock 2' },
+                        ] } }
+          it "raises a validation error with concatenated messages" do
+            method.should raise_error(RHC::Rest::ValidationException, "The server reported multiple errors:\n* mock 1\n* mock 2")
+          end
+        end
+        context "with multiple messages and one error" do
+          let(:json){ { :messages => [
+                          { :field => 'error', :text => 'mock 1' },
+                          { :text => 'mock 2' },
+                          { :severity => 'error', :text => 'mock 3' },
+                        ] } }
+          it "raises a validation error with concatenated messages" do
+            method.should raise_error(RHC::Rest::ValidationException, "mock 3")
           end
         end
       end
@@ -483,26 +573,27 @@ module RHC
         let(:code){ 500 }
 
         it "raises a generic server error" do
-          lambda { subject.process_error_response(response) }.should raise_error(RHC::Rest::ServerErrorException, /server did not respond correctly.*verify that you can access the OpenShift server/i)
+          method.should raise_error(RHC::Rest::ServerErrorException, /server did not respond correctly.*verify that you can access the OpenShift server/i)
         end
 
         context "when proxy is set" do
-          before{ RestClient.should_receive(:proxy).twice.and_return('http://foo.com') }
+          let(:proxy) { 'http://foo.com' }
           it "raises a generic server error with the proxy URL" do
-            lambda { subject.process_error_response(response) }.should raise_error(RHC::Rest::ServerErrorException, /foo\.com/i)
+            method.should raise_error(RHC::Rest::ServerErrorException, /foo\.com/i)
           end
         end
 
         context "when request url is present" do
+          let(:url){ 'foo.bar' }
           it "raises a generic server error with the request URL" do
-            lambda { subject.process_error_response(response, 'foo.bar') }.should raise_error(RHC::Rest::ServerErrorException, /foo\.bar/i)
+            method.should raise_error(RHC::Rest::ServerErrorException, /foo\.bar/i)
           end
         end
 
         context "with a formatted JSON response" do
           let(:json){ { :messages => [{ :severity => 'error', :text => 'mock error message' }] } }
           it "raises a server error" do
-            lambda { subject.process_error_response(response) }.should raise_error(RHC::Rest::ServerErrorException, 'mock error message')
+            method.should raise_error(RHC::Rest::ServerErrorException, 'mock error message')
           end
         end
       end
@@ -511,13 +602,13 @@ module RHC
         let(:code){ 503 }
 
         it "raises a 'service unavailable' error" do
-          lambda { subject.process_error_response(response) }.should raise_error(RHC::Rest::ServiceUnavailableException)
+          method.should raise_error(RHC::Rest::ServiceUnavailableException)
         end
 
         context "with a formatted JSON response" do
           let(:json){ { :messages => [{ :severity => 'error', :text => 'mock error message' }] } }
           it "raises a 'service unavailable' error" do
-            lambda { subject.process_error_response(response) }.should raise_error(RHC::Rest::ServiceUnavailableException, 'mock error message')
+            method.should raise_error(RHC::Rest::ServiceUnavailableException, 'mock error message')
           end
         end
       end
@@ -525,14 +616,12 @@ module RHC
       context "with an unhandled response code" do
         let(:code){ 999 }
 
-        it "raises a generic server error" do
-          lambda { subject.process_error_response(response) }.should raise_error(RHC::Rest::ServerErrorException)
-        end
+        it{ method.should raise_error(RHC::Rest::ServerErrorException) }
 
         context "with a formatted JSON response" do
           let(:json){ { :messages => [{ :severity => 'error', :text => 'mock error message' }] } }
           it "raises a resource access error" do
-            lambda { subject.process_error_response(response) }.should raise_error(RHC::Rest::ServerErrorException, 'Server returned an unexpected error code: 999')
+            method.should raise_error(RHC::Rest::ServerErrorException, 'mock error message')
           end
         end
       end