httparty 0.13.7 → 0.20.0

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,230 +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 "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
-  
-  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,173 +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
-  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