httparty 0.13.0 → 0.14.0

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
@@ -8,47 +8,47 @@ describe HTTParty::CookieHash do
   describe "#add_cookies" do
     describe "with a hash" 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)
+        @cookie_hash.add_cookies(foo: "bar")
+        @cookie_hash.add_cookies(rofl: "copter")
+        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")
+        @cookie_hash.add_cookies(foo: "bar")
+        @cookie_hash.add_cookies(foo: "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(RuntimeError)
       end
     end
   end
@@ -57,27 +57,44 @@ describe HTTParty::CookieHash do
   # a hardcoded string was randomly failing.
   describe "#to_cookie_string" do
     before(:each) do
-      @cookie_hash.add_cookies(:foo => "bar")
-      @cookie_hash.add_cookies(:rofl => "copter")
+      @cookie_hash.add_cookies(foo: "bar")
+      @cookie_hash.add_cookies(rofl: "copter")
       @s = @cookie_hash.to_cookie_string
     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 => "/")
+      @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 => "/")
+      @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 mutate the hash" do
+      original_hash = {
+        "session" => "91e25e8b-6e32-418d-c72f-2d18adf041cd",
+        "Max-Age" => "15552000",
+        "cart" => "91e25e8b-6e32-418d-c72f-2d18adf041cd",
+        "httponly" => nil,
+        "Path" => "/",
+        "secure" => nil,
+      }
+
+      cookie_hash = HTTParty::CookieHash[original_hash]
+
+      cookie_hash.to_cookie_string
+
+      expect(cookie_hash).to eq(original_hash)
     end
   end
 end

data/spec/httparty/exception_spec.rb

@@ -1,23 +1,45 @@
 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
+
+  describe HTTParty::DuplicateLocationHeader do
+    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,49 @@
+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 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

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

@@ -0,0 +1,119 @@
+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,22 +1,38 @@
 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::ApacheFormatter)
     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::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