httparty 0.17.0 → 0.17.1

data/spec/httparty/cookie_hash_spec.rb

@@ -1,100 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe HTTParty::CookieHash do
-  before(:each) do
-    @cookie_hash = HTTParty::CookieHash.new
-  end
-
-  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")
-        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")
-        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")
-        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")
-        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==")
-        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
-        expect {
-          @cookie_hash.add_cookies([])
-        }.to raise_error(RuntimeError)
-      end
-    end
-  end
-
-  # The regexen are required because Hashes aren't ordered, so a test against
-  # 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")
-      @s = @cookie_hash.to_cookie_string
-    end
-
-    it "should format the key/value pairs, delimited by semi-colons" do
-      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
-      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
-      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,45 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe HTTParty::Error do
-  subject { described_class }
-
-  describe '#ancestors' do
-    subject { super().ancestors }
-    it { is_expected.to include(StandardError) }
-  end
-
-  describe HTTParty::UnsupportedFormat do
-    describe '#ancestors' do
-      subject { super().ancestors }
-      it { is_expected.to include(HTTParty::Error) }
-    end
-  end
-
-  describe HTTParty::UnsupportedURIScheme do
-    describe '#ancestors' do
-      subject { super().ancestors }
-      it { is_expected.to include(HTTParty::Error) }
-    end
-  end
-
-  describe HTTParty::ResponseError do
-    describe '#ancestors' do
-      subject { super().ancestors }
-      it { is_expected.to include(HTTParty::Error) }
-    end
-  end
-
-  describe HTTParty::RedirectionTooDeep do
-    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

@@ -1,58 +0,0 @@
-require 'spec_helper'
-
-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
-
-    context "nested params" do
-      it 'creates a params string from a hash' do
-        hash = { marketing_event: { marketed_resources: [ {type:"product", id: 57474842640 } ] } }
-        expect(HTTParty::HashConversions.to_params(hash)).to eq("marketing_event[marketed_resources][][type]=product&marketing_event[marketed_resources][][id]=57474842640")
-      end
-    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

@@ -1,40 +0,0 @@
-require '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
-    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 '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("example.html")
-
-      response = HTTParty::Request.new.perform
-      subject.format(response.request, response)
-    end
-  end
-end

data/spec/httparty/logger/logger_spec.rb

@@ -1,43 +0,0 @@
-require '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 :logstash style logger" do
-      logger_double = double
-      expect(subject.build(logger_double, nil, :logstash)).to be_an_instance_of(HTTParty::Logger::LogstashFormatter)
-    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/logger/logstash_formatter_spec.rb

@@ -1,44 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe HTTParty::Logger::LogstashFormatter do
-  let(:severity) { :info }
-  let(:http_method) { 'GET' }
-  let(:path) { 'http://my.domain.com/my_path' }
-  let(:logger_double) { double('Logger') }
-  let(:request_double) { double('Request', http_method: Net::HTTP::Get, path: "#{path}") }
-  let(:request_time) { Time.new.strftime("%Y-%m-%d %H:%M:%S %z") }
-  let(:log_message) do
-    {
-      '@timestamp' => request_time,
-      '@version' => 1,
-      'content_length' => content_length || '-',
-      'http_method' => http_method,
-      'message' => message,
-      'path' => path,
-      'response_code' => response_code,
-      'severity' => severity,
-      'tags' => ['HTTParty'],
-    }.to_json
-  end
-
-  subject { described_class.new(logger_double, severity) }
-
-  before do
-    expect(logger_double).to receive(:info).with(log_message)
-  end
-
-  describe "#format" do
-    let(:response_code) { 302 }
-    let(:content_length) { '-' }
-    let(:message) { "[HTTParty] #{response_code} \"#{http_method} #{path}\" #{content_length} " }
-
-    it "formats a response to be compatible with Logstash" do
-      response_double = double(
-        code: response_code,
-        :[] => nil
-      )
-
-      subject.format(request_double, response_double)
-    end
-  end
-end