httparty 0.16.4 → 0.20.0

data/spec/httparty/hash_conversions_spec.rb

@@ -1,58 +0,0 @@
-require 'spec_helper'
-
-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
-
-    context "nested params" do
-      it 'creates a params string from a hash' do
-        hash = { marketing_event: { marketed_resources: [ {type:"product", id: 57474842640 } ] } }
-        expect(HTTParty::HashConversions.to_params(hash)).to eq("marketing_event[marketed_resources][][type]=product&marketing_event[marketed_resources][][id]=57474842640")
-      end
-    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

@@ -1,40 +0,0 @@
-require '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
-    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

@@ -1,119 +0,0 @@
-require '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("example.html")
-
-      response = HTTParty::Request.new.perform
-      subject.format(response.request, response)
-    end
-  end
-end

data/spec/httparty/logger/logger_spec.rb

@@ -1,43 +0,0 @@
-require '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 :logstash style logger" do
-      logger_double = double
-      expect(subject.build(logger_double, nil, :logstash)).to be_an_instance_of(HTTParty::Logger::LogstashFormatter)
-    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/logger/logstash_formatter_spec.rb

@@ -1,44 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe HTTParty::Logger::LogstashFormatter do
-  let(:severity) { :info }
-  let(:http_method) { 'GET' }
-  let(:path) { 'http://my.domain.com/my_path' }
-  let(:logger_double) { double('Logger') }
-  let(:request_double) { double('Request', http_method: Net::HTTP::Get, path: "#{path}") }
-  let(:request_time) { Time.new.strftime("%Y-%m-%d %H:%M:%S %z") }
-  let(:log_message) do
-    {
-      '@timestamp' => request_time,
-      '@version' => 1,
-      'content_length' => content_length || '-',
-      'http_method' => http_method,
-      'message' => message,
-      'path' => path,
-      'response_code' => response_code,
-      'severity' => severity,
-      'tags' => ['HTTParty'],
-    }.to_json
-  end
-
-  subject { described_class.new(logger_double, severity) }
-
-  before do
-    expect(logger_double).to receive(:info).with(log_message)
-  end
-
-  describe "#format" do
-    let(:response_code) { 302 }
-    let(:content_length) { '-' }
-    let(:message) { "[HTTParty] #{response_code} \"#{http_method} #{path}\" #{content_length} " }
-
-    it "formats a response to be compatible with Logstash" do
-      response_double = double(
-        code: response_code,
-        :[] => nil
-      )
-
-      subject.format(request_double, response_double)
-    end
-  end
-end

data/spec/httparty/net_digest_auth_spec.rb

@@ -1,270 +0,0 @@
-require '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 'Net::HTTPHeader#digest_auth' do
-    let(:headers) {
-      (Class.new do
-        include Net::HTTPHeader
-        def initialize
-          @header = {}
-          @path = '/'
-          @method = 'GET'
-        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({
-        '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 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