httparty 0.10.0 → 0.14.0

data/spec/httparty/response_spec.rb

@@ -1,12 +1,12 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
 
-describe HTTParty::Response do
+RSpec.describe HTTParty::Response do
   before do
     @last_modified = Date.new(2010, 1, 15).to_s
     @content_length = '1024'
     @request_object = HTTParty::Request.new Net::HTTP::Get, '/'
     @response_object = Net::HTTPOK.new('1.1', 200, 'OK')
-    @response_object.stub(:body => "{foo:'bar'}")
+    allow(@response_object).to receive_messages(body: "{foo:'bar'}")
     @response_object['last-modified'] = @last_modified
     @response_object['content-length'] = @content_length
     @parsed_response = lambda { {"foo" => "bar"} }
@@ -15,79 +15,111 @@ describe HTTParty::Response do
 
   describe ".underscore" do
     it "works with one capitalized word" do
-      HTTParty::Response.underscore("Accepted").should == "accepted"
+      expect(HTTParty::Response.underscore("Accepted")).to eq("accepted")
     end
 
     it "works with titlecase" do
-      HTTParty::Response.underscore("BadGateway").should == "bad_gateway"
+      expect(HTTParty::Response.underscore("BadGateway")).to eq("bad_gateway")
     end
 
     it "works with all caps" do
-      HTTParty::Response.underscore("OK").should == "ok"
+      expect(HTTParty::Response.underscore("OK")).to eq("ok")
     end
   end
 
   describe "initialization" do
     it "should set the Net::HTTP Response" do
-      @response.response.should == @response_object
+      expect(@response.response).to eq(@response_object)
     end
 
     it "should set body" do
-      @response.body.should == @response_object.body
+      expect(@response.body).to eq(@response_object.body)
     end
 
     it "should set code" do
-      @response.code.should.to_s == @response_object.code
+      expect(@response.code).to eq(@response_object.code)
     end
 
     it "should set code as a Fixnum" do
-      @response.code.should be_an_instance_of(Fixnum)
+      expect(@response.code).to be_an_instance_of(Fixnum)
+    end
+
+    context 'when raise_on is supplied' do
+      let(:request) { HTTParty::Request.new(Net::HTTP::Get, '/', raise_on: [404]) }
+
+      context "and response's status code is in range" do
+        let(:body)     { 'Not Found' }
+        let(:response) { Net::HTTPNotFound.new('1.1', 404, body) }
+
+        before do
+          allow(response).to receive(:body).and_return(body)
+        end
+
+        subject { described_class.new(request, response, @parsed_response) }
+
+        it 'throws exception' do
+          expect{ subject }.to raise_error(HTTParty::ResponseError, "Code 404 - #{body}")
+        end
+      end
+
+      context "and response's status code is not in range" do
+        subject { described_class.new(request, @response_object, @parsed_response) }
+
+        it 'does not throw exception' do
+          expect{ subject }.not_to raise_error(HTTParty::ResponseError)
+        end
+      end
     end
   end
 
   it "returns response headers" do
     response = HTTParty::Response.new(@request_object, @response_object, @parsed_response)
-    response.headers.should == {'last-modified' => [@last_modified], 'content-length' => [@content_length]}
+    expect(response.headers).to eq({'last-modified' => [@last_modified], 'content-length' => [@content_length]})
   end
 
   it "should send missing methods to delegate" do
     response = HTTParty::Response.new(@request_object, @response_object, @parsed_response)
-    response['foo'].should == 'bar'
+    expect(response['foo']).to eq('bar')
   end
 
   it "response to request" do
     response = HTTParty::Response.new(@request_object, @response_object, @parsed_response)
-    response.respond_to?(:request).should be_true
+    expect(response.respond_to?(:request)).to be_truthy
   end
 
   it "responds to response" do
     response = HTTParty::Response.new(@request_object, @response_object, @parsed_response)
-    response.respond_to?(:response).should be_true
+    expect(response.respond_to?(:response)).to be_truthy
   end
 
   it "responds to body" do
     response = HTTParty::Response.new(@request_object, @response_object, @parsed_response)
-    response.respond_to?(:body).should be_true
+    expect(response.respond_to?(:body)).to be_truthy
   end
 
   it "responds to headers" do
     response = HTTParty::Response.new(@request_object, @response_object, @parsed_response)
-    response.respond_to?(:headers).should be_true
+    expect(response.respond_to?(:headers)).to be_truthy
   end
 
   it "responds to parsed_response" do
     response = HTTParty::Response.new(@request_object, @response_object, @parsed_response)
-    response.respond_to?(:parsed_response).should be_true
+    expect(response.respond_to?(:parsed_response)).to be_truthy
+  end
+
+  it "responds to predicates" do
+    response = HTTParty::Response.new(@request_object, @response_object, @parsed_response)
+    expect(response.respond_to?(:success?)).to be_truthy
   end
 
   it "responds to anything parsed_response responds to" do
     response = HTTParty::Response.new(@request_object, @response_object, @parsed_response)
-    response.respond_to?(:[]).should be_true
+    expect(response.respond_to?(:[])).to be_truthy
   end
 
   it "should be able to iterate if it is array" do
     response = HTTParty::Response.new(@request_object, @response_object, lambda { [{'foo' => 'bar'}, {'foo' => 'baz'}] })
-    response.size.should == 2
+    expect(response.size).to eq(2)
     expect {
       response.each { |item| }
     }.to_not raise_error
@@ -95,14 +127,14 @@ describe HTTParty::Response do
 
   it "allows headers to be accessed by mixed-case names in hash notation" do
     response = HTTParty::Response.new(@request_object, @response_object, @parsed_response)
-    response.headers['Content-LENGTH'].should == @content_length
+    expect(response.headers['Content-LENGTH']).to eq(@content_length)
   end
 
   it "returns a comma-delimited value when multiple values exist" do
     @response_object.add_field 'set-cookie', 'csrf_id=12345; path=/'
     @response_object.add_field 'set-cookie', '_github_ses=A123CdE; path=/'
     response = HTTParty::Response.new(@request_object, @response_object, @parsed_response)
-    response.headers['set-cookie'].should == "csrf_id=12345; path=/, _github_ses=A123CdE; path=/"
+    expect(response.headers['set-cookie']).to eq("csrf_id=12345; path=/, _github_ses=A123CdE; path=/")
   end
 
   # Backwards-compatibility - previously, #headers returned a Hash
@@ -110,14 +142,32 @@ describe HTTParty::Response do
     response = HTTParty::Response.new(@request_object, @response_object, @parsed_response)
     hash_methods = {}.methods - response.headers.methods
     hash_methods.each do |method_name|
-      response.headers.respond_to?(method_name).should be_true
+      expect(response.headers.respond_to?(method_name)).to be_truthy
     end
   end
 
+  describe "#is_a?" do
+    subject { HTTParty::Response.new(@request_object, @response_object, @parsed_response) }
+
+    it { is_expected.to respond_to(:is_a?).with(1).arguments }
+    it { expect(subject.is_a?(HTTParty::Response)).to be_truthy }
+    it { expect(subject.is_a?(BasicObject)).to be_truthy }
+    it { expect(subject.is_a?(Object)).to be_falsey }
+  end
+
+  describe "#kind_of?" do
+    subject { HTTParty::Response.new(@request_object, @response_object, @parsed_response) }
+
+    it { is_expected.to respond_to(:kind_of?).with(1).arguments }
+    it { expect(subject.kind_of?(HTTParty::Response)).to be_truthy }
+    it { expect(subject.kind_of?(BasicObject)).to be_truthy }
+    it { expect(subject.kind_of?(Object)).to be_falsey }
+  end
+
   describe "semantic methods for response codes" do
     def response_mock(klass)
       response = klass.new('', '', '')
-      response.stub(:body)
+      allow(response).to receive(:body)
       response
     end
 
@@ -125,81 +175,88 @@ describe HTTParty::Response do
       it "is information" do
         net_response = response_mock(Net::HTTPInformation)
         response = HTTParty::Response.new(@request_object, net_response, '')
-        response.information?.should be_true
+        expect(response.information?).to be_truthy
       end
 
       it "is success" do
         net_response = response_mock(Net::HTTPSuccess)
         response = HTTParty::Response.new(@request_object, net_response, '')
-        response.success?.should be_true
+        expect(response.success?).to be_truthy
       end
 
       it "is redirection" do
         net_response = response_mock(Net::HTTPRedirection)
         response = HTTParty::Response.new(@request_object, net_response, '')
-        response.redirection?.should be_true
+        expect(response.redirection?).to be_truthy
       end
 
       it "is client error" do
         net_response = response_mock(Net::HTTPClientError)
         response = HTTParty::Response.new(@request_object, net_response, '')
-        response.client_error?.should be_true
+        expect(response.client_error?).to be_truthy
       end
 
       it "is server error" do
         net_response = response_mock(Net::HTTPServerError)
         response = HTTParty::Response.new(@request_object, net_response, '')
-        response.server_error?.should be_true
+        expect(response.server_error?).to be_truthy
       end
     end
 
     context "for specific codes" do
       SPECIFIC_CODES = {
-        :accepted?                        => Net::HTTPAccepted,
-        :bad_gateway?                     => Net::HTTPBadGateway,
-        :bad_request?                     => Net::HTTPBadRequest,
-        :conflict?                        => Net::HTTPConflict,
-        :continue?                        => Net::HTTPContinue,
-        :created?                         => Net::HTTPCreated,
-        :expectation_failed?              => Net::HTTPExpectationFailed,
-        :forbidden?                       => Net::HTTPForbidden,
-        :found?                           => Net::HTTPFound,
-        :gateway_time_out?                => Net::HTTPGatewayTimeOut,
-        :gone?                            => Net::HTTPGone,
-        :internal_server_error?           => Net::HTTPInternalServerError,
-        :length_required?                 => Net::HTTPLengthRequired,
-        :method_not_allowed?              => Net::HTTPMethodNotAllowed,
-        :moved_permanently?               => Net::HTTPMovedPermanently,
-        :multiple_choice?                 => Net::HTTPMultipleChoice,
-        :no_content?                      => Net::HTTPNoContent,
-        :non_authoritative_information?   => Net::HTTPNonAuthoritativeInformation,
-        :not_acceptable?                  => Net::HTTPNotAcceptable,
-        :not_found?                       => Net::HTTPNotFound,
-        :not_implemented?                 => Net::HTTPNotImplemented,
-        :not_modified?                    => Net::HTTPNotModified,
-        :ok?                              => Net::HTTPOK,
-        :partial_content?                 => Net::HTTPPartialContent,
-        :payment_required?                => Net::HTTPPaymentRequired,
-        :precondition_failed?             => Net::HTTPPreconditionFailed,
-        :proxy_authentication_required?   => Net::HTTPProxyAuthenticationRequired,
-        :request_entity_too_large?        => Net::HTTPRequestEntityTooLarge,
-        :request_time_out?                => Net::HTTPRequestTimeOut,
-        :request_uri_too_long?            => Net::HTTPRequestURITooLong,
-        :requested_range_not_satisfiable? => Net::HTTPRequestedRangeNotSatisfiable,
-        :reset_content?                   => Net::HTTPResetContent,
-        :see_other?                       => Net::HTTPSeeOther,
-        :service_unavailable?             => Net::HTTPServiceUnavailable,
-        :switch_protocol?                 => Net::HTTPSwitchProtocol,
-        :temporary_redirect?              => Net::HTTPTemporaryRedirect,
-        :unauthorized?                    => Net::HTTPUnauthorized,
-        :unsupported_media_type?          => Net::HTTPUnsupportedMediaType,
-        :use_proxy?                       => Net::HTTPUseProxy,
-        :version_not_supported?           => Net::HTTPVersionNotSupported
-      }.each do |method, klass|
+        accepted?:                        Net::HTTPAccepted,
+        bad_gateway?:                     Net::HTTPBadGateway,
+        bad_request?:                     Net::HTTPBadRequest,
+        conflict?:                        Net::HTTPConflict,
+        continue?:                        Net::HTTPContinue,
+        created?:                         Net::HTTPCreated,
+        expectation_failed?:              Net::HTTPExpectationFailed,
+        forbidden?:                       Net::HTTPForbidden,
+        found?:                           Net::HTTPFound,
+        gateway_time_out?:                Net::HTTPGatewayTimeOut,
+        gone?:                            Net::HTTPGone,
+        internal_server_error?:           Net::HTTPInternalServerError,
+        length_required?:                 Net::HTTPLengthRequired,
+        method_not_allowed?:              Net::HTTPMethodNotAllowed,
+        moved_permanently?:               Net::HTTPMovedPermanently,
+        multiple_choice?:                 Net::HTTPMultipleChoice,
+        no_content?:                      Net::HTTPNoContent,
+        non_authoritative_information?:   Net::HTTPNonAuthoritativeInformation,
+        not_acceptable?:                  Net::HTTPNotAcceptable,
+        not_found?:                       Net::HTTPNotFound,
+        not_implemented?:                 Net::HTTPNotImplemented,
+        not_modified?:                    Net::HTTPNotModified,
+        ok?:                              Net::HTTPOK,
+        partial_content?:                 Net::HTTPPartialContent,
+        payment_required?:                Net::HTTPPaymentRequired,
+        precondition_failed?:             Net::HTTPPreconditionFailed,
+        proxy_authentication_required?:   Net::HTTPProxyAuthenticationRequired,
+        request_entity_too_large?:        Net::HTTPRequestEntityTooLarge,
+        request_time_out?:                Net::HTTPRequestTimeOut,
+        request_uri_too_long?:            Net::HTTPRequestURITooLong,
+        requested_range_not_satisfiable?: Net::HTTPRequestedRangeNotSatisfiable,
+        reset_content?:                   Net::HTTPResetContent,
+        see_other?:                       Net::HTTPSeeOther,
+        service_unavailable?:             Net::HTTPServiceUnavailable,
+        switch_protocol?:                 Net::HTTPSwitchProtocol,
+        temporary_redirect?:              Net::HTTPTemporaryRedirect,
+        unauthorized?:                    Net::HTTPUnauthorized,
+        unsupported_media_type?:          Net::HTTPUnsupportedMediaType,
+        use_proxy?:                       Net::HTTPUseProxy,
+        version_not_supported?:           Net::HTTPVersionNotSupported
+      }
+
+      # Ruby 2.0, new name for this response.
+      if RUBY_VERSION >= "2.0.0" && ::RUBY_PLATFORM != "java"
+        SPECIFIC_CODES[:multiple_choices?] = Net::HTTPMultipleChoices
+      end
+
+      SPECIFIC_CODES.each do |method, klass|
         it "responds to #{method}" do
           net_response = response_mock(klass)
           response = HTTParty::Response.new(@request_object, net_response, '')
-          response.__send__(method).should be_true
+          expect(response.__send__(method)).to be_truthy
         end
       end
     end
@@ -208,7 +265,27 @@ describe HTTParty::Response do
   describe "headers" do
     it "can initialize without headers" do
       headers = HTTParty::Response::Headers.new
-      headers.should == {}
+      expect(headers).to eq({})
+    end
+  end
+
+  describe "#tap" do
+    it "is possible to tap into a response" do
+      result = @response.tap(&:code)
+
+      expect(result).to eq @response
+    end
+  end
+
+  describe "#inspect" do
+    it "works" do
+      inspect = @response.inspect
+      expect(inspect).to include("HTTParty::Response:0x")
+      expect(inspect).to include("parsed_response={\"foo\"=>\"bar\"}")
+      expect(inspect).to include("@response=#<Net::HTTPOK 200 OK readbody=false>")
+      expect(inspect).to include("@headers={")
+      expect(inspect).to include("last-modified")
+      expect(inspect).to include("content-length")
     end
   end
 end

data/spec/httparty/ssl_spec.rb

@@ -1,6 +1,6 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
 
-describe HTTParty::Request do
+RSpec.describe HTTParty::Request do
   context "SSL certificate verification" do
     before do
       FakeWeb.allow_net_connect = true
@@ -10,53 +10,65 @@ describe HTTParty::Request do
       FakeWeb.allow_net_connect = false
     end
 
-    it "should work when no trusted CA list is specified" do
-      ssl_verify_test(nil, nil, "selfsigned.crt").should == {'success' => true}
+    it "should fail when no trusted CA list is specified, by default" do
+      expect do
+        ssl_verify_test(nil, nil, "selfsigned.crt")
+      end.to raise_error OpenSSL::SSL::SSLError
     end
 
-    it "should work when no trusted CA list is specified, even with a bogus hostname" do
-      ssl_verify_test(nil, nil, "bogushost.crt").should == {'success' => true}
+    it "should work when no trusted CA list is specified, when the verify option is set to false" do
+      expect(ssl_verify_test(nil, nil, "selfsigned.crt", verify: false).parsed_response).to eq({'success' => true})
+    end
+
+    it "should fail when no trusted CA list is specified, with a bogus hostname, by default" do
+      expect do
+        ssl_verify_test(nil, nil, "bogushost.crt")
+      end.to raise_error OpenSSL::SSL::SSLError
+    end
+
+    it "should work when no trusted CA list is specified, even with a bogus hostname, when the verify option is set to true" do
+      expect(ssl_verify_test(nil, nil, "bogushost.crt", verify: false).parsed_response).to eq({'success' => true})
     end
 
     it "should work when using ssl_ca_file with a self-signed CA" do
-      ssl_verify_test(:ssl_ca_file, "selfsigned.crt", "selfsigned.crt").should == {'success' => true}
+      expect(ssl_verify_test(:ssl_ca_file, "selfsigned.crt", "selfsigned.crt").parsed_response).to eq({'success' => true})
     end
 
     it "should work when using ssl_ca_file with a certificate authority" do
-      ssl_verify_test(:ssl_ca_file, "ca.crt", "server.crt").should == {'success' => true}
+      expect(ssl_verify_test(:ssl_ca_file, "ca.crt", "server.crt").parsed_response).to eq({'success' => true})
     end
 
     it "should work when using ssl_ca_path with a certificate authority" do
-      http = Net::HTTP.new('www.google.com', 443, nil, nil, nil, nil)
-      response = stub(Net::HTTPResponse, :[] => '', :body => '', :to_hash => {})
-      http.stub(:request).and_return(response)
-      Net::HTTP.should_receive(:new).with('www.google.com', 443, nil, nil, nil, nil).and_return(http)
-      http.should_receive(:ca_path=).with('/foo/bar')
-      HTTParty.get('https://www.google.com', :ssl_ca_path => '/foo/bar')
+      http = Net::HTTP.new('www.google.com', 443)
+      response = double(Net::HTTPResponse, :[] => '', body: '', to_hash: {})
+      allow(http).to receive(:request).and_return(response)
+      expect(Net::HTTP).to receive(:new).with('www.google.com', 443).and_return(http)
+      expect(http).to receive(:ca_path=).with('/foo/bar')
+      HTTParty.get('https://www.google.com', ssl_ca_path: '/foo/bar')
     end
 
     it "should fail when using ssl_ca_file and the server uses an unrecognized certificate authority" do
-      lambda do
+      expect do
         ssl_verify_test(:ssl_ca_file, "ca.crt", "selfsigned.crt")
-      end.should raise_error(OpenSSL::SSL::SSLError)
+      end.to raise_error(OpenSSL::SSL::SSLError)
     end
 
     it "should fail when using ssl_ca_path and the server uses an unrecognized certificate authority" do
-      lambda do
+      expect do
         ssl_verify_test(:ssl_ca_path, ".", "selfsigned.crt")
-      end.should raise_error(OpenSSL::SSL::SSLError)
+      end.to raise_error(OpenSSL::SSL::SSLError)
     end
 
     it "should fail when using ssl_ca_file and the server uses a bogus hostname" do
-      lambda do
+      expect do
         ssl_verify_test(:ssl_ca_file, "ca.crt", "bogushost.crt")
-      end.should raise_error(OpenSSL::SSL::SSLError)
+      end.to raise_error(OpenSSL::SSL::SSLError)
     end
 
     it "should fail when using ssl_ca_path and the server uses a bogus hostname" do
-      lambda do
+      expect do
         ssl_verify_test(:ssl_ca_path, ".", "bogushost.crt")
-      end.should raise_error(OpenSSL::SSL::SSLError)
+      end.to raise_error(OpenSSL::SSL::SSLError)
     end
   end
 end