httparty 0.13.0 → 0.14.0

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
 
@@ -34,119 +62,179 @@ describe Net::HTTPHeader::DigestAuthenticator do
     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"',
+        'www-authenticate' => 'NTLM, 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 "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,64 +1,64 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
 
-describe HTTParty::Parser do
+RSpec.describe HTTParty::Parser do
   describe ".SupportedFormats" do
     it "returns a hash" do
-      HTTParty::Parser::SupportedFormats.should be_instance_of(Hash)
+      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
-      HTTParty::Parser.should_receive(:new).with('body', :plain).and_return(stub(:parse => nil))
+      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 = mock('Parser')
-      parser.should_receive(:parse)
-      HTTParty::Parser.stub(:new => parser)
+      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
-      HTTParty::Parser.formats.should == HTTParty::Parser::SupportedFormats
+      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
-      MyParser.formats.should == {"application/atom+xml" => :atom}
+      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
-      HTTParty::Parser.format_from_mimetype("text/plain").should == :plain
+      expect(HTTParty::Parser.format_from_mimetype("text/plain")).to eq(:plain)
     end
 
     it "returns nil when the mimetype is not supported" do
-      HTTParty::Parser.format_from_mimetype("application/atom+xml").should be_nil
+      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
-      HTTParty::Parser.supported_formats.should == HTTParty::Parser::SupportedFormats.values.uniq
+      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
-      HTTParty::Parser.stub(:supported_formats => [:json])
-      HTTParty::Parser.supports_format?(:json).should be_true
+      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
-      HTTParty::Parser.stub(:supported_formats => [])
-      HTTParty::Parser.supports_format?(:json).should be_false
+      allow(HTTParty::Parser).to receive_messages(supported_formats: [])
+      expect(HTTParty::Parser.supports_format?(:json)).to be_falsey
     end
   end
 
@@ -68,40 +68,46 @@ describe HTTParty::Parser do
     end
 
     it "attempts to parse supported formats" do
-      @parser.stub(:supports_format? => true)
-      @parser.should_receive(:parse_supported_format)
+      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
-      @parser.stub(:supports_format? => false)
-      @parser.parse.should == @parser.body
+      allow(@parser).to receive_messages(supports_format?: false)
+      expect(@parser.parse).to eq(@parser.body)
     end
 
     it "returns nil for an empty body" do
-      @parser.stub(:body => '')
-      @parser.parse.should be_nil
+      allow(@parser).to receive_messages(body: '')
+      expect(@parser.parse).to be_nil
     end
 
     it "returns nil for a nil body" do
-      @parser.stub(:body => nil)
-      @parser.parse.should be_nil
+      allow(@parser).to receive_messages(body: nil)
+      expect(@parser.parse).to be_nil
     end
 
     it "returns nil for a 'null' body" do
-      @parser.stub(:body => "null")
-      @parser.parse.should be_nil
+      allow(@parser).to receive_messages(body: "null")
+      expect(@parser.parse).to be_nil
     end
 
     it "returns nil for a body with spaces only" do
-      @parser.stub(:body => "   ")
-      @parser.parse.should be_nil
+      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
-      HTTParty::Parser.should_receive(:supports_format?).with(:json)
+      expect(HTTParty::Parser).to receive(:supports_format?).with(:json)
       parser = HTTParty::Parser.new('body', :json)
       parser.send(:supports_format?)
     end
@@ -110,7 +116,7 @@ describe HTTParty::Parser do
   describe "#parse_supported_format" do
     it "calls the parser for the given format" do
       parser = HTTParty::Parser.new('body', :json)
-      parser.should_receive(:json)
+      expect(parser).to receive(:json)
       parser.send(:parse_supported_format)
     end
 
@@ -124,7 +130,9 @@ describe HTTParty::Parser do
 
       it "raises a useful exception message for subclasses" do
         atom_parser = Class.new(HTTParty::Parser) do
-          def self.name; 'AtomParser'; end
+          def self.name
+            'AtomParser'
+          end
         end
         parser = atom_parser.new 'body', :atom
         expect do
@@ -140,25 +148,25 @@ describe HTTParty::Parser do
     end
 
     it "parses xml with MultiXml" do
-      MultiXml.should_receive(:parse).with('body')
+      expect(MultiXml).to receive(:parse).with('body')
       subject.send(:xml)
     end
 
     it "parses json with JSON" do
-      JSON.should_receive(:load).with('body', nil)
+      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
-      subject.send(:html).should == 'body'
+      expect(subject.send(:html)).to eq('body')
     end
 
     it "parses plain text by simply returning the body" do
-      subject.send(:plain).should == 'body'
+      expect(subject.send(:plain)).to eq('body')
     end
 
     it "parses csv with CSV" do
-      CSV.should_receive(:parse).with('body')
+      expect(CSV).to receive(:parse).with('body')
       subject.send(:csv)
     end
   end