httparty 0.13.3 → 0.13.4

data/spec/httparty/cookie_hash_spec.rb

@@ -1,6 +1,6 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
 
-describe HTTParty::CookieHash do
+RSpec.describe HTTParty::CookieHash do
   before(:each) do
     @cookie_hash = HTTParty::CookieHash.new
   end
@@ -10,45 +10,45 @@ describe HTTParty::CookieHash do
       it "should add new key/value pairs to the hash" do
         @cookie_hash.add_cookies(foo: "bar")
         @cookie_hash.add_cookies(rofl: "copter")
-        @cookie_hash.length.should eql(2)
+        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")
-        @cookie_hash.length.should eql(1)
-        @cookie_hash[:foo].should eql("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")
-        @cookie_hash[:first].should == 'one'
-        @cookie_hash[:second].should == 'two'
-        @cookie_hash[:third].should == nil
+        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")
-        @cookie_hash.length.should eql(1)
-        @cookie_hash[:foo].should eql("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==")
-          @cookie_hash.keys.should include(:first, :second)
-          @cookie_hash[:first].should == 'one=1'
-          @cookie_hash[:second].should == 'two=2=='
+        @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
-        lambda {
-          @cookie_hash.add_cookies(Array.new)
-        }.should raise_error
+        expect {
+          @cookie_hash.add_cookies([])
+        }.to raise_error
       end
     end
   end
@@ -63,21 +63,21 @@ describe HTTParty::CookieHash do
     end
 
     it "should format the key/value pairs, delimited by semi-colons" do
-      @s.should match(/foo=bar/)
-      @s.should match(/rofl=copter/)
-      @s.should match(/^\w+=\w+; \w+=\w+$/)
+      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
-      @s.should_not match(/path=\//)
+      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
-      @s.should_not match(/Path=\//)
+      expect(@s).not_to match(/Path=\//)
     end
   end
 end

data/spec/httparty/exception_spec.rb

@@ -1,23 +1,38 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
 
-describe HTTParty::Error do
+RSpec.describe HTTParty::Error do
   subject { described_class }
 
-  its(:ancestors) { should include(StandardError) }
+  describe '#ancestors' do
+    subject { super().ancestors }
+    it { is_expected.to include(StandardError) }
+  end
 
   describe HTTParty::UnsupportedFormat do
-    its(:ancestors) { should include(HTTParty::Error) }
+    describe '#ancestors' do
+      subject { super().ancestors }
+      it { is_expected.to include(HTTParty::Error) }
+    end
   end
-  
+
   describe HTTParty::UnsupportedURIScheme do
-    its(:ancestors) { should include(HTTParty::Error) }
+    describe '#ancestors' do
+      subject { super().ancestors }
+      it { is_expected.to include(HTTParty::Error) }
+    end
   end
 
   describe HTTParty::ResponseError do
-    its(:ancestors) { should include(HTTParty::Error) }
+    describe '#ancestors' do
+      subject { super().ancestors }
+      it { is_expected.to include(HTTParty::Error) }
+    end
   end
 
   describe HTTParty::RedirectionTooDeep do
-    its(:ancestors) { should include(HTTParty::ResponseError) }
+    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_logger_spec.rb

@@ -1,6 +1,6 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
 
-describe HTTParty::Logger::ApacheLogger do
+RSpec.describe HTTParty::Logger::ApacheLogger 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") }
@@ -8,7 +8,7 @@ describe HTTParty::Logger::ApacheLogger do
 
   before do
     subject.current_time = request_time
-    logger_double.should_receive(:info).with(log_message)
+    expect(logger_double).to receive(:info).with(log_message)
   end
 
   describe "#format" do
@@ -32,7 +32,7 @@ describe HTTParty::Logger::ApacheLogger do
             code: 200,
             headers: { 'Content-Length' => 512 }
         )
-        response_double.stub(:[]).with('Content-Length').and_raise(TypeError.new('no implicit conversion of String into Integer'))
+        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

data/spec/httparty/logger/curl_logger_spec.rb

@@ -1,10 +1,10 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
 
-describe HTTParty::Logger::CurlLogger do
+RSpec.describe HTTParty::Logger::CurlLogger do
   describe "#format" do
     it "formats a response in a style that resembles a -v curl" do
       logger_double = double
-      logger_double.should_receive(:info).with(
+      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)

data/spec/httparty/logger/logger_spec.rb

@@ -1,22 +1,22 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
 
-describe HTTParty::Logger do
+RSpec.describe HTTParty::Logger do
   describe ".build" do
     subject { HTTParty::Logger }
 
     it "defaults level to :info" do
-      logger_double = double()
-      subject.build(logger_double, nil, nil).level.should == :info
+      logger_double = double
+      expect(subject.build(logger_double, nil, nil).level).to eq(:info)
     end
 
     it "defaults format to :apache" do
-      logger_double = double()
-      subject.build(logger_double, nil, nil).should be_an_instance_of(HTTParty::Logger::ApacheLogger)
+      logger_double = double
+      expect(subject.build(logger_double, nil, nil)).to be_an_instance_of(HTTParty::Logger::ApacheLogger)
     end
 
     it "builds :curl style logger" do
-      logger_double = double()
-      subject.build(logger_double, nil, :curl).should be_an_instance_of(HTTParty::Logger::CurlLogger)
+      logger_double = double
+      expect(subject.build(logger_double, nil, :curl)).to be_an_instance_of(HTTParty::Logger::CurlLogger)
     end
   end
 end

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,130 +62,130 @@ 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',
+        'www-authenticate' => 'Digest realm="myhost@testrealm.com", nonce="NONCE", qop=auth'
       })
     end
 
     it "should still set qop" do
-      authorization_header.should include(%Q(qop="auth"))
+      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 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
 end