httparty 0.10.0 → 0.14.0

data/spec/httparty/exception_spec.rb

@@ -0,0 +1,45 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+RSpec.describe HTTParty::Error do
+  subject { described_class }
+
+  describe '#ancestors' do
+    subject { super().ancestors }
+    it { is_expected.to include(StandardError) }
+  end
+
+  describe HTTParty::UnsupportedFormat do
+    describe '#ancestors' do
+      subject { super().ancestors }
+      it { is_expected.to include(HTTParty::Error) }
+    end
+  end
+
+  describe HTTParty::UnsupportedURIScheme do
+    describe '#ancestors' do
+      subject { super().ancestors }
+      it { is_expected.to include(HTTParty::Error) }
+    end
+  end
+
+  describe HTTParty::ResponseError do
+    describe '#ancestors' do
+      subject { super().ancestors }
+      it { is_expected.to include(HTTParty::Error) }
+    end
+  end
+
+  describe HTTParty::RedirectionTooDeep do
+    describe '#ancestors' do
+      subject { super().ancestors }
+      it { is_expected.to include(HTTParty::ResponseError) }
+    end
+  end
+
+  describe HTTParty::DuplicateLocationHeader do
+    describe '#ancestors' do
+      subject { super().ancestors }
+      it { is_expected.to include(HTTParty::ResponseError) }
+    end
+  end
+end

data/spec/httparty/hash_conversions_spec.rb

@@ -0,0 +1,49 @@
+RSpec.describe HTTParty::HashConversions do
+  describe ".to_params" do
+    it "creates a params string from a hash" do
+      hash = {
+        name: "bob",
+        address: {
+          street: '111 ruby ave.',
+          city: 'ruby central',
+          phones: ['111-111-1111', '222-222-2222']
+        }
+      }
+      expect(HTTParty::HashConversions.to_params(hash)).to eq("name=bob&address[street]=111%20ruby%20ave.&address[city]=ruby%20central&address[phones][]=111-111-1111&address[phones][]=222-222-2222")
+    end
+  end
+
+  describe ".normalize_param" do
+    context "value is an array" do
+      it "creates a params string" do
+        expect(
+          HTTParty::HashConversions.normalize_param(:people, ["Bob Jones", "Mike Smith"])
+        ).to eq("people[]=Bob%20Jones&people[]=Mike%20Smith&")
+      end
+    end
+
+    context "value is an empty array" do
+      it "creates a params string" do
+        expect(
+          HTTParty::HashConversions.normalize_param(:people, [])
+        ).to eq("people[]=&")
+      end
+    end
+
+    context "value is hash" do
+      it "creates a params string" do
+        expect(
+          HTTParty::HashConversions.normalize_param(:person, { name: "Bob Jones" })
+        ).to eq("person[name]=Bob%20Jones&")
+      end
+    end
+
+    context "value is a string" do
+      it "creates a params string" do
+        expect(
+          HTTParty::HashConversions.normalize_param(:name, "Bob Jones")
+        ).to eq("name=Bob%20Jones&")
+      end
+    end
+  end
+end

data/spec/httparty/logger/apache_formatter_spec.rb

@@ -0,0 +1,41 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+RSpec.describe HTTParty::Logger::ApacheFormatter do
+  let(:subject) { described_class.new(logger_double, :info) }
+  let(:logger_double) { double('Logger') }
+  let(:request_double) { double('Request', http_method: Net::HTTP::Get, path: "http://my.domain.com/my_path") }
+  let(:request_time) { Time.new.strftime("%Y-%m-%d %H:%M:%S %z") }
+
+  before do
+    subject.current_time = request_time
+    expect(logger_double).to receive(:info).with(log_message)
+  end
+
+  describe "#format" do
+    let(:log_message) { "[HTTParty] [#{request_time}] 302 \"GET http://my.domain.com/my_path\" - " }
+
+    it "formats a response in a style that resembles apache's access log" do
+      response_double = double(
+        code: 302,
+        :[] => nil
+      )
+
+      subject.format(request_double, response_double)
+    end
+
+    context 'when there is a parsed response' do
+      let(:log_message) { "[HTTParty] [#{request_time}] 200 \"GET http://my.domain.com/my_path\" 512 "}
+
+      it "can handle the Content-Length header" do
+        # Simulate a parsed response that is an array, where accessing a string key will raise an error. See Issue #299.
+        response_double = double(
+            code: 200,
+            headers: { 'Content-Length' => 512 }
+        )
+        allow(response_double).to receive(:[]).with('Content-Length').and_raise(TypeError.new('no implicit conversion of String into Integer'))
+
+        subject.format(request_double, response_double)
+      end
+    end
+  end
+end

data/spec/httparty/logger/curl_formatter_spec.rb

@@ -0,0 +1,119 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+RSpec.describe HTTParty::Logger::CurlFormatter do
+  describe "#format" do
+    let(:logger)          { double('Logger') }
+    let(:response_object) { Net::HTTPOK.new('1.1', 200, 'OK') }
+    let(:parsed_response) { lambda { {"foo" => "bar"} } }
+
+    let(:response) do
+      HTTParty::Response.new(request, response_object, parsed_response)
+    end
+
+    let(:request) do
+      HTTParty::Request.new(Net::HTTP::Get, 'http://foo.bar.com/')
+    end
+
+    subject { described_class.new(logger, :info) }
+
+    before do
+      allow(logger).to receive(:info)
+      allow(request).to receive(:raw_body).and_return('content')
+      allow(response_object).to receive_messages(body: "{foo:'bar'}")
+      response_object['header-key'] = 'header-value'
+
+      subject.format request, response
+    end
+
+    context 'when request is logged' do
+      context "and request's option 'base_uri' is not present" do
+        it 'logs url' do
+          expect(logger).to have_received(:info).with(/\[HTTParty\] \[\d{4}-\d\d-\d\d \d\d:\d\d:\d\d\ [+-]\d{4}\] > GET http:\/\/foo.bar.com/)
+        end
+      end
+
+      context "and request's option 'base_uri' is present" do
+        let(:request) do
+          HTTParty::Request.new(Net::HTTP::Get, '/path', base_uri: 'http://foo.bar.com')
+        end
+
+        it 'logs url' do
+          expect(logger).to have_received(:info).with(/\[HTTParty\] \[\d{4}-\d\d-\d\d \d\d:\d\d:\d\d\ [+-]\d{4}\] > GET http:\/\/foo.bar.com\/path/)
+        end
+      end
+
+      context 'and headers are not present' do
+        it 'not log Headers' do
+          expect(logger).not_to have_received(:info).with(/Headers/)
+        end
+      end
+
+      context 'and headers are present' do
+        let(:request) do
+          HTTParty::Request.new(Net::HTTP::Get, '/path', base_uri: 'http://foo.bar.com', headers: { key: 'value' })
+        end
+
+        it 'logs Headers' do
+          expect(logger).to have_received(:info).with(/Headers/)
+        end
+
+        it 'logs headers keys' do
+          expect(logger).to have_received(:info).with(/key: value/)
+        end
+      end
+
+      context 'and query is not present' do
+        it 'not logs Query' do
+          expect(logger).not_to have_received(:info).with(/Query/)
+        end
+      end
+
+      context 'and query is present' do
+        let(:request) do
+          HTTParty::Request.new(Net::HTTP::Get, '/path', query: { key: 'value' })
+        end
+
+        it 'logs Query' do
+          expect(logger).to have_received(:info).with(/Query/)
+        end
+
+        it 'logs query params' do
+          expect(logger).to have_received(:info).with(/key: value/)
+        end
+      end
+
+      context 'when request raw_body is present' do
+        it 'not logs request body' do
+          expect(logger).to have_received(:info).with(/content/)
+        end
+      end
+    end
+
+    context 'when response is logged' do
+      it 'logs http version and response code' do
+        expect(logger).to have_received(:info).with(/HTTP\/1.1 200/)
+      end
+
+      it 'logs headers' do
+        expect(logger).to have_received(:info).with(/Header-key: header-value/)
+      end
+
+      it 'logs body' do
+        expect(logger).to have_received(:info).with(/{foo:'bar'}/)
+      end
+    end
+
+    it "formats a response in a style that resembles a -v curl" do
+      logger_double = double
+      expect(logger_double).to receive(:info).with(
+          /\[HTTParty\] \[\d{4}-\d\d-\d\d \d\d:\d\d:\d\d\ [+-]\d{4}\] > GET http:\/\/localhost/)
+
+      subject = described_class.new(logger_double, :info)
+
+      stub_http_response_with("google.html")
+
+      response = HTTParty::Request.new.perform
+      subject.format(response.request, response)
+    end
+  end
+end

data/spec/httparty/logger/logger_spec.rb

@@ -0,0 +1,38 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+RSpec.describe HTTParty::Logger do
+  describe ".build" do
+    subject { HTTParty::Logger }
+
+    it "defaults level to :info" do
+      logger_double = double
+      expect(subject.build(logger_double, nil, nil).level).to eq(:info)
+    end
+
+    it "defaults format to :apache" do
+      logger_double = double
+      expect(subject.build(logger_double, nil, nil)).to be_an_instance_of(HTTParty::Logger::ApacheFormatter)
+    end
+
+    it "builds :curl style logger" do
+      logger_double = double
+      expect(subject.build(logger_double, nil, :curl)).to be_an_instance_of(HTTParty::Logger::CurlFormatter)
+    end
+
+    it "builds :custom style logger" do
+      CustomFormatter = Class.new(HTTParty::Logger::CurlFormatter)
+      HTTParty::Logger.add_formatter(:custom, CustomFormatter)
+
+      logger_double = double
+      expect(subject.build(logger_double, nil, :custom)).
+        to be_an_instance_of(CustomFormatter)
+    end
+    it "raises error when formatter exists" do
+      CustomFormatter2= Class.new(HTTParty::Logger::CurlFormatter)
+      HTTParty::Logger.add_formatter(:custom2, CustomFormatter2)
+
+      expect{ HTTParty::Logger.add_formatter(:custom2, CustomFormatter2) }.
+        to raise_error HTTParty::Error
+    end
+  end
+end

data/spec/httparty/net_digest_auth_spec.rb

@@ -1,11 +1,11 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
 
-describe Net::HTTPHeader::DigestAuthenticator do
+RSpec.describe Net::HTTPHeader::DigestAuthenticator do
   def setup_digest(response)
     digest = Net::HTTPHeader::DigestAuthenticator.new("Mufasa",
-      "Circle Of Life", "GET", "/dir/index.html", response)
-    digest.stub(:random).and_return("deadbeef")
-    Digest::MD5.stub(:hexdigest) { |str| "md5(#{str})" }
+                                                      "Circle Of Life", "GET", "/dir/index.html", response)
+    allow(digest).to receive(:random).and_return("deadbeef")
+    allow(Digest::MD5).to receive(:hexdigest) { |str| "md5(#{str})" }
     digest
   end
 
@@ -13,6 +13,34 @@ describe Net::HTTPHeader::DigestAuthenticator do
     @digest.authorization_header.join(", ")
   end
 
+  def cookie_header
+    @digest.cookie_header
+  end
+
+  context "with a cookie value in the response header" do
+    before do
+      @digest = setup_digest({
+        'www-authenticate' => 'Digest realm="myhost@testrealm.com"',
+        'Set-Cookie' => 'custom-cookie=1234567'
+      })
+    end
+
+    it "should set cookie header" do
+      expect(cookie_header).to include('custom-cookie=1234567')
+    end
+  end
+
+  context "without a cookie value in the response header" do
+    before do
+      @digest = setup_digest({
+        'www-authenticate' => 'Digest realm="myhost@testrealm.com"'
+      })
+    end
+
+    it "should set empty cookie header array" do
+      expect(cookie_header).to eql []
+    end
+  end
 
   context "with an opaque value in the response header" do
     before do
@@ -22,7 +50,7 @@ describe Net::HTTPHeader::DigestAuthenticator do
     end
 
     it "should set opaque" do
-      authorization_header.should include(%Q(opaque="solid"))
+      expect(authorization_header).to include('opaque="solid"')
     end
   end
 
@@ -30,86 +58,183 @@ describe Net::HTTPHeader::DigestAuthenticator do
     before do
       @digest = setup_digest({
         'www-authenticate' => 'Digest realm="myhost@testrealm.com"'
-      })  
+      })
     end
 
     it "should not set opaque" do
-      authorization_header.should_not include(%Q(opaque=)) 
+      expect(authorization_header).not_to include("opaque=")
     end
   end
 
   context "with specified quality of protection (qop)" do
     before do
       @digest = setup_digest({
-        'www-authenticate' => 'Digest realm="myhost@testrealm.com", nonce="NONCE", qop="auth"',
+        'www-authenticate' => 'Digest realm="myhost@testrealm.com", nonce="NONCE", qop="auth"'
       })
     end
 
     it "should set prefix" do
-      authorization_header.should =~ /^Digest /
+      expect(authorization_header).to match(/^Digest /)
     end
 
     it "should set username" do
-      authorization_header.should include(%Q(username="Mufasa"))
+      expect(authorization_header).to include('username="Mufasa"')
     end
 
     it "should set digest-uri" do
-      authorization_header.should include(%Q(uri="/dir/index.html"))
+      expect(authorization_header).to include('uri="/dir/index.html"')
     end
 
     it "should set qop" do
-      authorization_header.should include(%Q(qop="auth"))
+      expect(authorization_header).to include('qop="auth"')
     end
 
     it "should set cnonce" do
-      authorization_header.should include(%Q(cnonce="md5(deadbeef)"))
+      expect(authorization_header).to include('cnonce="md5(deadbeef)"')
     end
 
     it "should set nonce-count" do
-      authorization_header.should include(%Q(nc="00000001"))
+      expect(authorization_header).to include("nc=00000001")
     end
 
     it "should set response" do
       request_digest = "md5(md5(Mufasa:myhost@testrealm.com:Circle Of Life):NONCE:00000001:md5(deadbeef):auth:md5(GET:/dir/index.html))"
-      authorization_header.should include(%Q(response="#{request_digest}"))
+      expect(authorization_header).to include(%(response="#{request_digest}"))
     end
   end
 
+  context "when quality of protection (qop) is unquoted" do
+    before do
+      @digest = setup_digest({
+        'www-authenticate' => 'Digest realm="myhost@testrealm.com", nonce="NONCE", qop=auth'
+      })
+    end
+
+    it "should still set qop" do
+      expect(authorization_header).to include('qop="auth"')
+    end
+  end
 
   context "with unspecified quality of protection (qop)" do
     before do
       @digest = setup_digest({
-        'www-authenticate' => 'Digest realm="myhost@testrealm.com", nonce="NONCE"',
+        'www-authenticate' => 'Digest realm="myhost@testrealm.com", nonce="NONCE"'
       })
     end
 
     it "should set prefix" do
-      authorization_header.should =~ /^Digest /
+      expect(authorization_header).to match(/^Digest /)
     end
 
     it "should set username" do
-      authorization_header.should include(%Q(username="Mufasa"))
+      expect(authorization_header).to include('username="Mufasa"')
     end
 
     it "should set digest-uri" do
-      authorization_header.should include(%Q(uri="/dir/index.html"))
+      expect(authorization_header).to include('uri="/dir/index.html"')
     end
 
     it "should not set qop" do
-      authorization_header.should_not include(%Q(qop=))
+      expect(authorization_header).not_to include("qop=")
     end
 
     it "should not set cnonce" do
-      authorization_header.should_not include(%Q(cnonce=))
+      expect(authorization_header).not_to include("cnonce=")
     end
 
     it "should not set nonce-count" do
-      authorization_header.should_not include(%Q(nc=))
+      expect(authorization_header).not_to include("nc=")
     end
 
     it "should set response" do
       request_digest = "md5(md5(Mufasa:myhost@testrealm.com:Circle Of Life):NONCE:md5(GET:/dir/index.html))"
-      authorization_header.should include(%Q(response="#{request_digest}"))
+      expect(authorization_header).to include(%(response="#{request_digest}"))
+    end
+  end
+
+  context "with http basic auth response when net digest auth expected" do
+    it "should not fail" do
+      @digest = setup_digest({
+                               'www-authenticate' => 'WWW-Authenticate: Basic realm="testrealm.com""'
+                           })
+
+      expect(authorization_header).to include("Digest")
+    end
+  end
+
+  context "with multiple authenticate headers" do
+    before do
+      @digest = setup_digest({
+        'www-authenticate' => 'NTLM, Digest realm="myhost@testrealm.com", nonce="NONCE", qop="auth"'
+      })
+    end
+
+    it "should set prefix" do
+      expect(authorization_header).to match(/^Digest /)
+    end
+
+    it "should set username" do
+      expect(authorization_header).to include('username="Mufasa"')
+    end
+
+    it "should set digest-uri" do
+      expect(authorization_header).to include('uri="/dir/index.html"')
+    end
+
+    it "should set qop" do
+      expect(authorization_header).to include('qop="auth"')
+    end
+
+    it "should set cnonce" do
+      expect(authorization_header).to include('cnonce="md5(deadbeef)"')
+    end
+
+    it "should set nonce-count" do
+      expect(authorization_header).to include("nc=00000001")
+    end
+
+    it "should set response" do
+      request_digest = "md5(md5(Mufasa:myhost@testrealm.com:Circle Of Life):NONCE:00000001:md5(deadbeef):auth:md5(GET:/dir/index.html))"
+      expect(authorization_header).to include(%(response="#{request_digest}"))
+    end
+  end
+  
+  context "with algorithm specified" do
+    before do
+      @digest = setup_digest({
+                              'www-authenticate' => 'Digest realm="myhost@testrealm.com", nonce="NONCE", qop="auth", algorithm=MD5'
+                             })
+    end
+    
+    it "should recognise algorithm was specified" do
+      expect( @digest.send :algorithm_present? ).to be(true)
+    end
+    
+    it "should set the algorithm header" do
+      expect(authorization_header).to include('algorithm="MD5"')
+    end
+  end
+
+  context "with md5-sess algorithm specified" do
+    before do
+      @digest = setup_digest({
+                              'www-authenticate' => 'Digest realm="myhost@testrealm.com", nonce="NONCE", qop="auth", algorithm=MD5-sess'
+                             })
+    end
+    
+    it "should recognise algorithm was specified" do
+      expect( @digest.send :algorithm_present? ).to be(true)
+    end
+    
+    it "should set the algorithm header" do
+      expect(authorization_header).to include('algorithm="MD5-sess"')
+    end
+    
+    it "should set response using md5-sess algorithm" do
+      request_digest = "md5(md5(md5(Mufasa:myhost@testrealm.com:Circle Of Life):NONCE:md5(deadbeef)):NONCE:00000001:md5(deadbeef):auth:md5(GET:/dir/index.html))"
+      expect(authorization_header).to include(%(response="#{request_digest}"))
     end
+    
   end
+  
 end