httpserious 0.13.5.lstoll1

data/spec/httparty/cookie_hash_spec.rb

@@ -0,0 +1,83 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
+
+RSpec.describe HTTParty::CookieHash do
+  before(:each) do
+    @cookie_hash = HTTParty::CookieHash.new
+  end
+
+  describe "#add_cookies" do
+    describe "with a hash" do
+      it "should add new key/value pairs to the hash" do
+        @cookie_hash.add_cookies(foo: "bar")
+        @cookie_hash.add_cookies(rofl: "copter")
+        expect(@cookie_hash.length).to eql(2)
+      end
+
+      it "should overwrite any existing key" do
+        @cookie_hash.add_cookies(foo: "bar")
+        @cookie_hash.add_cookies(foo: "copter")
+        expect(@cookie_hash.length).to eql(1)
+        expect(@cookie_hash[:foo]).to eql("copter")
+      end
+    end
+
+    describe "with a string" do
+      it "should add new key/value pairs to the hash" do
+        @cookie_hash.add_cookies("first=one; second=two; third")
+        expect(@cookie_hash[:first]).to eq('one')
+        expect(@cookie_hash[:second]).to eq('two')
+        expect(@cookie_hash[:third]).to eq(nil)
+      end
+
+      it "should overwrite any existing key" do
+        @cookie_hash[:foo] = 'bar'
+        @cookie_hash.add_cookies("foo=tar")
+        expect(@cookie_hash.length).to eql(1)
+        expect(@cookie_hash[:foo]).to eql("tar")
+      end
+
+      it "should handle '=' within cookie value" do
+        @cookie_hash.add_cookies("first=one=1; second=two=2==")
+        expect(@cookie_hash.keys).to include(:first, :second)
+        expect(@cookie_hash[:first]).to eq('one=1')
+        expect(@cookie_hash[:second]).to eq('two=2==')
+      end
+    end
+
+    describe 'with other class' do
+      it "should error" do
+        expect {
+          @cookie_hash.add_cookies([])
+        }.to raise_error
+      end
+    end
+  end
+
+  # The regexen are required because Hashes aren't ordered, so a test against
+  # a hardcoded string was randomly failing.
+  describe "#to_cookie_string" do
+    before(:each) do
+      @cookie_hash.add_cookies(foo: "bar")
+      @cookie_hash.add_cookies(rofl: "copter")
+      @s = @cookie_hash.to_cookie_string
+    end
+
+    it "should format the key/value pairs, delimited by semi-colons" do
+      expect(@s).to match(/foo=bar/)
+      expect(@s).to match(/rofl=copter/)
+      expect(@s).to match(/^\w+=\w+; \w+=\w+$/)
+    end
+
+    it "should not include client side only cookies" do
+      @cookie_hash.add_cookies(path: "/")
+      @s = @cookie_hash.to_cookie_string
+      expect(@s).not_to match(/path=\//)
+    end
+
+    it "should not include client side only cookies even when attributes use camal case" do
+      @cookie_hash.add_cookies(Path: "/")
+      @s = @cookie_hash.to_cookie_string
+      expect(@s).not_to match(/Path=\//)
+    end
+  end
+end

data/spec/httparty/exception_spec.rb

@@ -0,0 +1,38 @@
+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
+end

data/spec/httparty/hash_conversions_spec.rb

@@ -0,0 +1,41 @@
+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 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,18 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+RSpec.describe HTTParty::Logger::CurlFormatter do
+  describe "#format" do
+    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

@@ -0,0 +1,191 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+RSpec.describe Net::HTTPHeader::DigestAuthenticator do
+  def setup_digest(response)
+    digest = Net::HTTPHeader::DigestAuthenticator.new("Mufasa",
+                                                      "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
+
+  def authorization_header
+    @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
+      @digest = setup_digest({
+        'www-authenticate' => 'Digest realm="myhost@testrealm.com", opaque="solid"'
+      })
+    end
+
+    it "should set opaque" do
+      expect(authorization_header).to include('opaque="solid"')
+    end
+  end
+
+  context "without an opaque valid in the response header" do
+    before do
+      @digest = setup_digest({
+        'www-authenticate' => 'Digest realm="myhost@testrealm.com"'
+      })
+    end
+
+    it "should not set opaque" do
+      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"'
+      })
+    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 "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"'
+      })
+    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 not set qop" do
+      expect(authorization_header).not_to include("qop=")
+    end
+
+    it "should not set cnonce" do
+      expect(authorization_header).not_to include("cnonce=")
+    end
+
+    it "should not set nonce-count" do
+      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))"
+      expect(authorization_header).to include(%(response="#{request_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
+end