httparty 0.14.0 → 0.15.0

data/lib/httparty/response.rb

@@ -1,5 +1,5 @@
 module HTTParty
-  class Response < BasicObject
+  class Response < Object
     def self.underscore(string)
       string.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z])([A-Z])/, '\1_\2').downcase
     end
@@ -25,16 +25,6 @@ module HTTParty
       @parsed_response ||= @parsed_block.call
     end
 
-    def class
-      Response
-    end
-
-    def is_a?(klass)
-      self.class == klass || self.class < klass
-    end
-
-    alias_method :kind_of?, :is_a?
-
     def code
       response.code.to_i
     end
@@ -49,16 +39,12 @@ module HTTParty
       %(#<#{self.class}:0x#{inspect_id} parsed_response=#{parsed_response.inspect}, @response=#{response.inspect}, @headers=#{headers.inspect}>)
     end
 
-    RESPOND_TO_METHODS = [:request, :response, :parsed_response, :body, :headers]
-
     CODES_TO_OBJ = ::Net::HTTPResponse::CODE_CLASS_TO_OBJ.merge ::Net::HTTPResponse::CODE_TO_OBJ
 
     CODES_TO_OBJ.each do |response_code, klass|
       name = klass.name.sub("Net::HTTP", '')
       name = "#{underscore(name)}?".to_sym
 
-      RESPOND_TO_METHODS << name
-
       define_method(name) do
         klass === response
       end
@@ -69,11 +55,33 @@ module HTTParty
       alias_method :multiple_choice?, :multiple_choices?
     end
 
-    def respond_to?(name, include_all = false)
-      return true if RESPOND_TO_METHODS.include?(name)
-      parsed_response.respond_to?(name, include_all) || response.respond_to?(name, include_all)
+    def nil?
+      response.nil? || response.body.nil? || response.body.empty?
     end
 
+    def to_s      
+      if !response.nil? && !response.body.nil? && response.body.respond_to?(:to_s)
+        response.body.to_s
+      else 
+        inspect
+      end
+    end
+
+    def display(port=$>)
+      if !parsed_response.nil? && parsed_response.respond_to?(:display)
+        parsed_response.display(port)
+      elsif !response.nil? && !response.body.nil? && response.body.respond_to?(:display)
+        response.body.display(port)
+      else 
+        port.write(inspect)
+      end
+    end
+
+    def respond_to_missing?(name, *args)
+      return true if super
+      parsed_response.respond_to?(name) || response.respond_to?(name)
+    end
+    
     protected
 
     def method_missing(name, *args, &block)

data/lib/httparty/response/headers.rb

@@ -1,31 +1,31 @@
 module HTTParty
   class Response #:nodoc:
-    class Headers
+    class Headers < ::SimpleDelegator
       include ::Net::HTTPHeader
 
-      def initialize(header = {})
-        @header = header
+      def initialize(header_values = nil)
+        @header = {}
+        if header_values
+          header_values.each_pair do |k,v|
+            if v.is_a?(Array)
+              v.each do |sub_v|
+                add_field(k, sub_v)
+              end
+            else
+              add_field(k, v)
+            end
+          end
+        end
+        super(@header)
       end
 
       def ==(other)
-        @header == other
-      end
-
-      def inspect
-        @header.inspect
-      end
-
-      def method_missing(name, *args, &block)
-        if @header.respond_to?(name)
-          @header.send(name, *args, &block)
-        else
-          super
+        if other.is_a?(::Net::HTTPHeader) 
+          @header == other.instance_variable_get(:@header)
+        elsif other.is_a?(Hash)
+          @header == other || @header == Headers.new(other).instance_variable_get(:@header)           
         end
       end
-
-      def respond_to?(method, include_all = false)
-        super || @header.respond_to?(method, include_all)
-      end
     end
   end
 end

data/lib/httparty/version.rb

@@ -1,3 +1,3 @@
 module HTTParty
-  VERSION = "0.14.0"
+  VERSION = "0.15.0"
 end

data/spec/fixtures/ssl/generated/1fe462c2.0

@@ -0,0 +1 @@
+ca.crt

data/spec/httparty/net_digest_auth_spec.rb

@@ -17,6 +17,34 @@ RSpec.describe Net::HTTPHeader::DigestAuthenticator do
     @digest.cookie_header
   end
 
+  context 'Net::HTTPHeader#digest_auth' do
+    let(:headers) {
+      (Class.new do 
+        include Net::HTTPHeader
+        def initialize
+          @header = {}
+        end
+      end).new
+    } 
+
+    let(:response){
+      (Class.new do 
+        include Net::HTTPHeader
+        def initialize
+          @header = {}
+          self['WWW-Authenticate'] = 
+          'Digest realm="testrealm@host.com", qop="auth,auth-int", nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093", opaque="5ccc069c403ebaf9f0171e9517f40e41"'
+        end
+      end).new
+    }
+
+    it 'should set the authorization header' do 
+      expect(headers['authorization']).to be_nil
+      headers.digest_auth('user','pass', response)
+      expect(headers['authorization']).to_not be_empty
+    end 
+  end 
+
   context "with a cookie value in the response header" do
     before do
       @digest = setup_digest({

data/spec/httparty/parser_spec.rb

@@ -103,6 +103,11 @@ RSpec.describe HTTParty::Parser do
       allow(@parser).to receive_messages(supports_format?: false)
       expect(@parser.parse).to_not be_nil
     end
+
+    it "ignores utf-8 bom" do
+      allow(@parser).to receive_messages(body: "\xEF\xBB\xBF\{\"hi\":\"yo\"\}")
+      expect(@parser.parse).to eq({"hi"=>"yo"})
+    end
   end
 
   describe "#supports_format?" do

data/spec/httparty/request_spec.rb

@@ -33,6 +33,34 @@ RSpec.describe HTTParty::Request do
     end
   end
 
+  describe "::JSON_API_QUERY_STRING_NORMALIZER" do
+    let(:normalizer) { HTTParty::Request::JSON_API_QUERY_STRING_NORMALIZER }
+
+    it "doesn't modify strings" do
+      query_string = normalizer["foo=bar&foo=baz"]
+      expect(CGI.unescape(query_string)).to eq("foo=bar&foo=baz")
+    end
+
+    context "when the query is an array" do
+      it "doesn't include brackets" do
+        query_string = normalizer[{page: 1, foo: %w(bar baz)}]
+        expect(CGI.unescape(query_string)).to eq("foo=bar,baz&page=1")
+      end
+
+      it "URI encodes array values" do
+        query_string = normalizer[{people: ["Otis Redding", "Bob Marley", "Tim & Jon"], page: 1, xyzzy: 3}]
+        expect(query_string).to eq("page=1&people=Otis%20Redding,Bob%20Marley,Tim%20%26%20Jon&xyzzy=3")
+      end
+    end
+
+    context "when the query is a hash" do
+      it "correctly handles nil values" do
+        query_string = normalizer[{page: 1, per_page: nil}]
+        expect(query_string).to eq('page=1&per_page')
+      end
+    end
+  end
+
   describe "initialization" do
     it "sets parser to HTTParty::Parser" do
       request = HTTParty::Request.new(Net::HTTP::Get, 'http://google.com')
@@ -129,55 +157,82 @@ RSpec.describe HTTParty::Request do
       expect(@request.instance_variable_get(:@raw_request)['authorization']).not_to be_nil
     end
 
-    it "should use digest auth when configured" do
-      FakeWeb.register_uri(:get, "http://api.foo.com/v1",
-                           www_authenticate: 'Digest realm="Log Viewer", qop="auth", nonce="2CA0EC6B0E126C4800E56BA0C0003D3C", opaque="5ccc069c403ebaf9f0171e9517f40e41", stale=false')
-
-      @request.options[:digest_auth] = {username: 'foobar', password: 'secret'}
-      @request.send(:setup_raw_request)
-
-      raw_request = @request.instance_variable_get(:@raw_request)
-      expect(raw_request.instance_variable_get(:@header)['Authorization']).not_to be_nil
-    end
-
-    it "should use the right http method for digest authentication" do
-      @post_request = HTTParty::Request.new(Net::HTTP::Post, 'http://api.foo.com/v1', format: :xml)
-      FakeWeb.register_uri(:post, "http://api.foo.com/v1", {})
-
-      http = @post_request.send(:http)
-      expect(@post_request).to receive(:http).and_return(http)
-      expect(http).not_to receive(:head).with({'www-authenticate' => nil})
-      @post_request.options[:digest_auth] = {username: 'foobar', password: 'secret'}
-      @post_request.send(:setup_raw_request)
-    end
-
-    it 'should maintain cookies returned from setup_digest_auth' do
-      FakeWeb.register_uri(
-        :get, "http://api.foo.com/v1",
-        set_cookie: 'custom-cookie=1234567',
-        www_authenticate: 'Digest realm="Log Viewer", qop="auth", nonce="2CA0EC6B0E126C4800E56BA0C0003D3C", opaque="5ccc069c403ebaf9f0171e9517f40e41", stale=false'
-      )
-
-      @request.options[:digest_auth] = {username: 'foobar', password: 'secret'}
-      @request.send(:setup_raw_request)
-
-      raw_request = @request.instance_variable_get(:@raw_request)
-      expect(raw_request.instance_variable_get(:@header)['cookie']).to eql ["custom-cookie=1234567"]
-    end
-
-    it 'should merge cookies from setup_digest_auth and request' do
-      FakeWeb.register_uri(
-        :get, "http://api.foo.com/v1",
-        set_cookie: 'custom-cookie=1234567',
-        www_authenticate: 'Digest realm="Log Viewer", qop="auth", nonce="2CA0EC6B0E126C4800E56BA0C0003D3C", opaque="5ccc069c403ebaf9f0171e9517f40e41", stale=false'
-      )
-
-      @request.options[:digest_auth] = {username: 'foobar', password: 'secret'}
-      @request.options[:headers] = {'cookie' => 'request-cookie=test'}
-      @request.send(:setup_raw_request)
-
-      raw_request = @request.instance_variable_get(:@raw_request)
-      expect(raw_request.instance_variable_get(:@header)['cookie']).to eql ['request-cookie=test', 'custom-cookie=1234567']
+    context 'digest_auth' do 
+      before do 
+        response_sequence = [
+          {status: ['401', 'Unauthorized' ], 
+            www_authenticate: 'Digest realm="Log Viewer", qop="auth", nonce="2CA0EC6B0E126C4800E56BA0C0003D3C", opaque="5ccc069c403ebaf9f0171e9517f40e41", stale=false',
+            set_cookie: 'custom-cookie=1234567', 
+          },
+          {status: ['200', 'OK']}
+        ]      
+        FakeWeb.register_uri(:get, "http://api.foo.com/v1",
+                            response_sequence)
+      end 
+
+      it 'should not send credentials more than once' do
+        response_sequence = [
+          {status: ['401', 'Unauthorized' ], 
+            www_authenticate: 'Digest realm="Log Viewer", qop="auth", nonce="2CA0EC6B0E126C4800E56BA0C0003D3C", opaque="5ccc069c403ebaf9f0171e9517f40e41", stale=false',
+            set_cookie: 'custom-cookie=1234567', 
+          },
+          {status: ['401', 'Unauthorized' ], 
+            www_authenticate: 'Digest realm="Log Viewer", qop="auth", nonce="2CA0EC6B0E126C4800E56BA0C0003D3C", opaque="5ccc069c403ebaf9f0171e9517f40e41", stale=false',
+            set_cookie: 'custom-cookie=1234567', 
+          },      
+          {status: ['404', 'Not found']}
+        ]      
+        FakeWeb.register_uri(:get, "http://api.foo.com/v1",
+                            response_sequence)
+
+        @request.options[:digest_auth] = {username: 'foobar', password: 'secret'}        
+        response = @request.perform { |v| }
+        expect(response.code).to eq(401)
+
+        raw_request = @request.instance_variable_get(:@raw_request)
+        expect(raw_request['Authorization']).not_to be_nil                    
+      end 
+
+      it 'should not be used when configured and the response is 200' do
+        FakeWeb.register_uri(:get, "http://api.foo.com/v1",
+          status: 200)
+        @request.options[:digest_auth] = {username: 'foobar', password: 'secret'}        
+        response = @request.perform { |v| }
+        expect(response.code).to eq(200)
+
+
+        raw_request = @request.instance_variable_get(:@raw_request)
+        expect(raw_request['Authorization']).to be_nil
+      end
+
+      it "should be used when configured and the response is 401" do
+        @request.options[:digest_auth] = {username: 'foobar', password: 'secret'}        
+        response = @request.perform { |v| }
+        expect(response.code).to eq(200)
+
+        raw_request = @request.instance_variable_get(:@raw_request)
+        expect(raw_request['Authorization']).not_to be_nil
+      end
+
+      it 'should maintain cookies returned from a 401 response' do
+        @request.options[:digest_auth] = {username: 'foobar', password: 'secret'}        
+        response = @request.perform {|v|}
+        expect(response.code).to eq(200)
+        
+        raw_request = @request.instance_variable_get(:@raw_request)
+        expect(raw_request.get_fields('cookie')).to eql ["custom-cookie=1234567"]
+      end
+
+      it 'should merge cookies from request and a 401 response' do
+        
+        @request.options[:digest_auth] = {username: 'foobar', password: 'secret'}
+        @request.options[:headers] = {'cookie' => 'request-cookie=test'}
+        response = @request.perform {|v|}
+        expect(response.code).to eq(200)
+
+        raw_request = @request.instance_variable_get(:@raw_request)
+        expect(raw_request.get_fields('cookie')).to eql ['request-cookie=test', 'custom-cookie=1234567']
+      end
     end
 
     it 'should use body_stream when configured' do
@@ -230,6 +285,14 @@ RSpec.describe HTTParty::Request do
 
         expect(@request.uri).to eq(URI.parse("http://example.com/bar?foo=bar"))
       end
+
+      it "returns correct path when the server sets the location header to a network-path reference" do
+        @request.last_uri = URI.parse("https://example.com")
+        @request.path = URI.parse("//www.example.com")
+        @request.redirect = true
+
+        expect(@request.uri).to eq(URI.parse("https://www.example.com"))
+      end
     end
 
     context "query strings" do
@@ -360,6 +423,12 @@ RSpec.describe HTTParty::Request do
       expect(@request.send(:parse_response, xml)).to eq({'books' => {'book' => {'id' => '1234', 'name' => 'Foo Bar!'}}})
     end
 
+    it 'should handle utf-8 bom in xml' do
+      xml = "\xEF\xBB\xBF<books><book><id>1234</id><name>Foo Bar!</name></book></books>"
+      @request.options[:format] = :xml
+      expect(@request.send(:parse_response, xml)).to eq({'books' => {'book' => {'id' => '1234', 'name' => 'Foo Bar!'}}})
+    end
+
     it 'should handle csv automatically' do
       csv = ['"id","Name"', '"1234","Foo Bar!"'].join("\n")
       @request.options[:format] = :csv
@@ -372,6 +441,12 @@ RSpec.describe HTTParty::Request do
       expect(@request.send(:parse_response, json)).to eq({'books' => {'book' => {'id' => '1234', 'name' => 'Foo Bar!'}}})
     end
 
+    it 'should handle utf-8 bom in json' do
+      json = "\xEF\xBB\xBF{\"books\": {\"book\": {\"name\": \"Foo Bar!\", \"id\": \"1234\"}}}"
+      @request.options[:format] = :json
+      expect(@request.send(:parse_response, json)).to eq({'books' => {'book' => {'id' => '1234', 'name' => 'Foo Bar!'}}})
+    end
+
     it "should include any HTTP headers in the returned response" do
       @request.options[:format] = :html
       response = stub_response "Content"
@@ -382,10 +457,15 @@ RSpec.describe HTTParty::Request do
 
     if "".respond_to?(:encoding)
 
+      let(:response_charset) {
+        @request.send(:get_charset)
+      }
+
       it "should process charset in content type properly" do
         response = stub_response "Content"
         response.initialize_http_header("Content-Type" => "text/plain;charset = utf-8")
         resp = @request.perform
+        expect(response_charset).to_not be_empty
         expect(resp.body.encoding).to eq(Encoding.find("UTF-8"))
       end
 
@@ -393,6 +473,7 @@ RSpec.describe HTTParty::Request do
         response = stub_response "Content"
         response.initialize_http_header("Content-Type" => "text/plain;CHARSET = utf-8")
         resp = @request.perform
+        expect(response_charset).to_not be_empty
         expect(resp.body.encoding).to eq(Encoding.find("UTF-8"))
       end
 
@@ -400,6 +481,7 @@ RSpec.describe HTTParty::Request do
         response = stub_response "Content"
         response.initialize_http_header("Content-Type" => "text/plain;charset = \"utf-8\"")
         resp = @request.perform
+        expect(response_charset).to_not be_empty
         expect(resp.body.encoding).to eq(Encoding.find("UTF-8"))
       end
 
@@ -409,6 +491,7 @@ RSpec.describe HTTParty::Request do
         response = stub_response "\xFF\xFEC\x00o\x00n\x00t\x00e\x00n\x00t\x00"
         response.initialize_http_header("Content-Type" => "text/plain;charset = utf-16")
         resp = @request.perform
+        expect(response_charset).to_not be_empty
         expect(resp.body.encoding).to eq(Encoding.find("UTF-16LE"))
       end
 
@@ -418,6 +501,7 @@ RSpec.describe HTTParty::Request do
         response = stub_response "\xFE\xFF\x00C\x00o\x00n\x00t\x00e\x00n\x00t"
         response.initialize_http_header("Content-Type" => "text/plain;charset = utf-16")
         resp = @request.perform
+        expect(response_charset).to_not be_empty
         expect(resp.body.encoding).to eq(Encoding.find("UTF-16BE"))
       end
 
@@ -427,6 +511,7 @@ RSpec.describe HTTParty::Request do
         response = stub_response "C\x00o\x00n\x00t\x00e\x00n\x00t\x00"
         response.initialize_http_header("Content-Type" => "text/plain;charset = utf-16")
         resp = @request.perform
+        expect(response_charset).to_not be_empty
         expect(resp.body.encoding).to eq(Encoding.find("UTF-16LE"))
       end
 
@@ -434,6 +519,9 @@ RSpec.describe HTTParty::Request do
         response = stub_response "Content"
         response.initialize_http_header("Content-Type" => "text/plain;charset = utf-lols")
         resp = @request.perform
+        expect(response_charset).to_not be_empty        
+        # This encoding does not exist, thus the string should not be encodd with it
+        expect(resp.body.encoding).to_not eq(response_charset)
         expect(resp.body).to eq("Content")
         expect(resp.body.encoding).to eq("Content".encoding)
       end
@@ -442,6 +530,7 @@ RSpec.describe HTTParty::Request do
         response = stub_response "Content"
         response.initialize_http_header("Content-Type" => "text/plain")
         resp = @request.perform
+        expect(response_charset).to be_nil
         expect(resp.body).to eq("Content")
         expect(resp.body.encoding).to eq("Content".encoding)
       end
@@ -1037,54 +1126,6 @@ RSpec.describe HTTParty::Request do
     end
   end
 
-  describe "#handle_deflation" do
-    context "context-encoding" do
-      before do
-        @request.options[:format] = :html
-        @last_response = double
-        allow(@last_response).to receive(:body).and_return('')
-      end
-
-      it "should inflate the gzipped body with content-encoding: gzip" do
-        allow(@last_response).to receive(:[]).with("content-encoding").and_return("gzip")
-        allow(@request).to receive(:last_response).and_return(@last_response)
-        expect(Zlib::GzipReader).to receive(:new).and_return(StringIO.new(''))
-        expect(@request.last_response).to receive(:delete).with('content-encoding')
-        @request.send(:handle_deflation)
-      end
-
-      it "should inflate the gzipped body with content-encoding: x-gzip" do
-        allow(@last_response).to receive(:[]).with("content-encoding").and_return("x-gzip")
-        allow(@request).to receive(:last_response).and_return(@last_response)
-        expect(Zlib::GzipReader).to receive(:new).and_return(StringIO.new(''))
-        expect(@request.last_response).to receive(:delete).with('content-encoding')
-        @request.send(:handle_deflation)
-      end
-
-      it "should inflate the deflated body" do
-        allow(@last_response).to receive(:[]).with("content-encoding").and_return("deflate")
-        allow(@request).to receive(:last_response).and_return(@last_response)
-        expect(Zlib::Inflate).to receive(:inflate).and_return('')
-        expect(@request.last_response).to receive(:delete).with('content-encoding')
-        @request.send(:handle_deflation)
-      end
-
-      it "should not inflate a redirected response with content-encoding: gzip" do
-        allow(@last_response).to receive(:[]).with("content-encoding").and_return("gzip")
-        allow(@request).to receive(:last_response).and_return(@last_response)
-        allow(@request).to receive(:response_redirects?).and_return(true)
-        @request.send(:handle_deflation)
-      end
-
-      it "should not inflate a redirected response with content-encoding: deflate" do
-        allow(@last_response).to receive(:[]).with("content-encoding").and_return("deflate")
-        allow(@request).to receive(:last_response).and_return(@last_response)
-        allow(@request).to receive(:response_redirects?).and_return(true)
-        @request.send(:handle_deflation)
-      end
-    end
-  end
-
   describe "#send_authorization_header?" do
     context "basic_auth" do
       before do
@@ -1180,4 +1221,24 @@ RSpec.describe HTTParty::Request do
       }.to raise_error(HTTParty::RedirectionTooDeep, 'HTTP redirects too deep')
     end
   end
+
+  context 'with Accept-Encoding header' do
+    it 'should disable content decoding if present' do 
+      request = HTTParty::Request.new(Net::HTTP::Get, 'http://api.foo.com/v1', headers:{'Accept-Encoding' => 'custom'})
+      request.send(:setup_raw_request)
+      expect(request.instance_variable_get(:@raw_request).decode_content).to eq(false)
+    end
+
+    it 'should disable content decoding if present and lowercase' do 
+      request = HTTParty::Request.new(Net::HTTP::Get, 'http://api.foo.com/v1', headers:{'accept-encoding' => 'custom'})
+      request.send(:setup_raw_request)
+      expect(request.instance_variable_get(:@raw_request).decode_content).to eq(false)
+    end
+
+    it 'should disable content decoding if present' do 
+      request = HTTParty::Request.new(Net::HTTP::Get, 'http://api.foo.com/v1')
+      request.send(:setup_raw_request)
+      expect(request.instance_variable_get(:@raw_request).decode_content).to eq(true)
+    end
+  end
 end