httparty 0.15.4 → 0.20.0

data/spec/httparty/logger/apache_formatter_spec.rb

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

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

@@ -1,38 +0,0 @@
-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,268 +0,0 @@
-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 '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({
-        '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

data/spec/httparty/parser_spec.rb

@@ -1,185 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
-
-RSpec.describe HTTParty::Parser do
-  describe ".SupportedFormats" do
-    it "returns a hash" do
-      expect(HTTParty::Parser::SupportedFormats).to be_instance_of(Hash)
-    end
-  end
-
-  describe ".call" do
-    it "generates an HTTParty::Parser instance with the given body and format" do
-      expect(HTTParty::Parser).to receive(:new).with('body', :plain).and_return(double(parse: nil))
-      HTTParty::Parser.call('body', :plain)
-    end
-
-    it "calls #parse on the parser" do
-      parser = double('Parser')
-      expect(parser).to receive(:parse)
-      allow(HTTParty::Parser).to receive_messages(new: parser)
-      parser = HTTParty::Parser.call('body', :plain)
-    end
-  end
-
-  describe ".formats" do
-    it "returns the SupportedFormats constant" do
-      expect(HTTParty::Parser.formats).to eq(HTTParty::Parser::SupportedFormats)
-    end
-
-    it "returns the SupportedFormats constant for subclasses" do
-      class MyParser < HTTParty::Parser
-        SupportedFormats = {"application/atom+xml" => :atom}
-      end
-      expect(MyParser.formats).to eq({"application/atom+xml" => :atom})
-    end
-  end
-
-  describe ".format_from_mimetype" do
-    it "returns a symbol representing the format mimetype" do
-      expect(HTTParty::Parser.format_from_mimetype("text/plain")).to eq(:plain)
-    end
-
-    it "returns nil when the mimetype is not supported" do
-      expect(HTTParty::Parser.format_from_mimetype("application/atom+xml")).to be_nil
-    end
-  end
-
-  describe ".supported_formats" do
-    it "returns a unique set of supported formats represented by symbols" do
-      expect(HTTParty::Parser.supported_formats).to eq(HTTParty::Parser::SupportedFormats.values.uniq)
-    end
-  end
-
-  describe ".supports_format?" do
-    it "returns true for a supported format" do
-      allow(HTTParty::Parser).to receive_messages(supported_formats: [:json])
-      expect(HTTParty::Parser.supports_format?(:json)).to be_truthy
-    end
-
-    it "returns false for an unsupported format" do
-      allow(HTTParty::Parser).to receive_messages(supported_formats: [])
-      expect(HTTParty::Parser.supports_format?(:json)).to be_falsey
-    end
-  end
-
-  describe "#parse" do
-    before do
-      @parser = HTTParty::Parser.new('body', :json)
-    end
-
-    it "attempts to parse supported formats" do
-      allow(@parser).to receive_messages(supports_format?: true)
-      expect(@parser).to receive(:parse_supported_format)
-      @parser.parse
-    end
-
-    it "returns the unparsed body when the format is unsupported" do
-      allow(@parser).to receive_messages(supports_format?: false)
-      expect(@parser.parse).to eq(@parser.body)
-    end
-
-    it "returns nil for an empty body" do
-      allow(@parser).to receive_messages(body: '')
-      expect(@parser.parse).to be_nil
-    end
-
-    it "returns nil for a nil body" do
-      allow(@parser).to receive_messages(body: nil)
-      expect(@parser.parse).to be_nil
-    end
-
-    it "returns nil for a 'null' body" do
-      allow(@parser).to receive_messages(body: "null")
-      expect(@parser.parse).to be_nil
-    end
-
-    it "returns nil for a body with spaces only" do
-      allow(@parser).to receive_messages(body: "   ")
-      expect(@parser.parse).to be_nil
-    end
-
-    it "does not raise exceptions for bodies with invalid encodings" do
-      allow(@parser).to receive_messages(body: "\x80")
-      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
-
-    it "parses ascii 8bit encoding" do
-      allow(@parser).to receive_messages(
-        body: "{\"currency\":\"\xE2\x82\xAC\"}".force_encoding('ASCII-8BIT')
-      )
-      expect(@parser.parse).to eq({"currency" => "€"})
-    end
-  end
-
-  describe "#supports_format?" do
-    it "utilizes the class method to determine if the format is supported" do
-      expect(HTTParty::Parser).to receive(:supports_format?).with(:json)
-      parser = HTTParty::Parser.new('body', :json)
-      parser.send(:supports_format?)
-    end
-  end
-
-  describe "#parse_supported_format" do
-    it "calls the parser for the given format" do
-      parser = HTTParty::Parser.new('body', :json)
-      expect(parser).to receive(:json)
-      parser.send(:parse_supported_format)
-    end
-
-    context "when a parsing method does not exist for the given format" do
-      it "raises an exception" do
-        parser = HTTParty::Parser.new('body', :atom)
-        expect do
-          parser.send(:parse_supported_format)
-        end.to raise_error(NotImplementedError, "HTTParty::Parser has not implemented a parsing method for the :atom format.")
-      end
-
-      it "raises a useful exception message for subclasses" do
-        atom_parser = Class.new(HTTParty::Parser) do
-          def self.name
-            'AtomParser'
-          end
-        end
-        parser = atom_parser.new 'body', :atom
-        expect do
-          parser.send(:parse_supported_format)
-        end.to raise_error(NotImplementedError, "AtomParser has not implemented a parsing method for the :atom format.")
-      end
-    end
-  end
-
-  context "parsers" do
-    subject do
-      HTTParty::Parser.new('body', nil)
-    end
-
-    it "parses xml with MultiXml" do
-      expect(MultiXml).to receive(:parse).with('body')
-      subject.send(:xml)
-    end
-
-    it "parses json with JSON" do
-      expect(JSON).to receive(:parse).with('body', :quirks_mode => true, :allow_nan => true)
-      subject.send(:json)
-    end
-
-    it "parses html by simply returning the body" do
-      expect(subject.send(:html)).to eq('body')
-    end
-
-    it "parses plain text by simply returning the body" do
-      expect(subject.send(:plain)).to eq('body')
-    end
-
-    it "parses csv with CSV" do
-      expect(CSV).to receive(:parse).with('body')
-      subject.send(:csv)
-    end
-  end
-end