httsoiree 0.13.1

data/spec/httparty/connection_adapter_spec.rb

@@ -0,0 +1,370 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe HTTParty::ConnectionAdapter do
+
+  describe "initialization" do
+    let(:uri) { URI 'http://www.google.com' }
+    it "takes a URI as input" do
+      HTTParty::ConnectionAdapter.new(uri)
+    end
+
+    it "raises an ArgumentError if the uri is nil" do
+      expect { HTTParty::ConnectionAdapter.new(nil) }.to raise_error ArgumentError
+    end
+
+    it "raises an ArgumentError if the uri is a String" do
+      expect { HTTParty::ConnectionAdapter.new('http://www.google.com') }.to raise_error ArgumentError
+    end
+
+    it "sets the uri" do
+      adapter = HTTParty::ConnectionAdapter.new(uri)
+      adapter.uri.should be uri
+    end
+
+    it "also accepts an optional options hash" do
+      HTTParty::ConnectionAdapter.new(uri, {})
+    end
+
+    it "sets the options" do
+      options = {foo: :bar}
+      adapter = HTTParty::ConnectionAdapter.new(uri, options)
+      adapter.options.should be options
+    end
+  end
+
+  describe ".call" do
+    it "generates an HTTParty::ConnectionAdapter instance with the given uri and options" do
+      HTTParty::ConnectionAdapter.should_receive(:new).with(@uri, @options).and_return(stub(connection: nil))
+      HTTParty::ConnectionAdapter.call(@uri, @options)
+    end
+
+    it "calls #connection on the connection adapter" do
+      adapter = mock('Adapter')
+      connection = mock('Connection')
+      adapter.should_receive(:connection).and_return(connection)
+      HTTParty::ConnectionAdapter.stub(new: adapter)
+      HTTParty::ConnectionAdapter.call(@uri, @options).should be connection
+    end
+  end
+
+  describe '#connection' do
+    let(:uri) { URI 'http://www.google.com' }
+    let(:options) { Hash.new }
+    let(:adapter) { HTTParty::ConnectionAdapter.new(uri, options) }
+
+    describe "the resulting connection" do
+      subject { adapter.connection }
+      it { should be_an_instance_of Net::HTTP }
+
+      context "using port 80" do
+        let(:uri) { URI 'http://foobar.com' }
+        it { should_not use_ssl }
+      end
+
+      context "when dealing with ssl" do
+        let(:uri) { URI 'https://foobar.com' }
+
+        context "uses the system cert_store, by default" do
+          let(:system_cert_store) do
+            system_cert_store = mock('default_cert_store')
+            system_cert_store.should_receive(:set_default_paths)
+            OpenSSL::X509::Store.should_receive(:new).and_return(system_cert_store)
+            system_cert_store
+          end
+          it { should use_cert_store(system_cert_store) }
+        end
+
+        context "should use the specified cert store, when one is given" do
+          let(:custom_cert_store) { mock('custom_cert_store') }
+          let(:options) { {cert_store: custom_cert_store} }
+          it { should use_cert_store(custom_cert_store) }
+        end
+
+        context "using port 443 for ssl" do
+          let(:uri) { URI 'https://api.foo.com/v1:443' }
+          it { should use_ssl }
+        end
+
+        context "https scheme with default port" do
+          it { should use_ssl }
+        end
+
+        context "https scheme with non-standard port" do
+          let(:uri) { URI 'https://foobar.com:123456' }
+          it { should use_ssl }
+        end
+
+
+        context "when ssl version is set" do
+          let(:options) { {ssl_version: :TLSv1} }
+
+          it "sets ssl version" do
+            subject.ssl_version.should == :TLSv1
+          end
+        end if RUBY_VERSION > '1.9'
+      end
+
+      context "when dealing with IPv6" do
+        let(:uri) { URI 'http://[fd00::1]' }
+
+        it "strips brackets from the address" do
+          subject.address.should == 'fd00::1'
+        end
+      end
+
+      context "specifying ciphers" do
+        let(:options) { {ciphers: 'RC4-SHA' } }
+
+        it "should set the ciphers on the connection" do
+          subject.ciphers.should == 'RC4-SHA'
+        end
+      end if RUBY_VERSION > '1.9'
+
+      context "when timeout is not set" do
+        it "doesn't set the timeout" do
+          http = mock("http", null_object: true)
+          http.should_not_receive(:open_timeout=)
+          http.should_not_receive(:read_timeout=)
+          Net::HTTP.stub(new: http)
+
+          adapter.connection
+        end
+      end
+
+      context "when setting timeout" do
+        context "to 5 seconds" do
+          let(:options) { {timeout: 5} }
+
+          its(:open_timeout) { should == 5 }
+          its(:read_timeout) { should == 5 }
+        end
+
+        context "and timeout is a string" do
+          let(:options) { {timeout: "five seconds"} }
+
+          it "doesn't set the timeout" do
+            http = mock("http", null_object: true)
+            http.should_not_receive(:open_timeout=)
+            http.should_not_receive(:read_timeout=)
+            Net::HTTP.stub(new: http)
+
+            adapter.connection
+          end
+        end
+      end
+
+      context "when timeout is not set and read_timeout is set to 6 seconds" do
+        let(:options) { {read_timeout: 6} }
+
+        its(:read_timeout) { should == 6 }
+
+        it "should not set the open_timeout" do
+          http = mock("http", null_object: true)
+          http.should_not_receive(:open_timeout=)
+          Net::HTTP.stub(new: http)
+          adapter.connection
+        end
+      end
+
+      context "when timeout is set and read_timeout is set to 6 seconds" do
+        let(:options) { {timeout: 5, read_timeout: 6} }
+
+        its(:open_timeout) { should == 5 }
+        its(:read_timeout) { should == 6 }
+
+        it "should override the timeout option" do
+          http = mock("http", null_object: true)
+          http.should_receive(:open_timeout=)
+          http.should_receive(:read_timeout=).twice
+          Net::HTTP.stub(new: http)
+          adapter.connection
+        end
+      end
+
+      context "when timeout is not set and open_timeout is set to 7 seconds" do
+        let(:options) { {open_timeout: 7} }
+
+        its(:open_timeout) { should == 7 }
+
+        it "should not set the read_timeout" do
+          http = mock("http", null_object: true)
+          http.should_not_receive(:read_timeout=)
+          Net::HTTP.stub(new: http)
+          adapter.connection
+        end
+      end
+
+      context "when timeout is set and open_timeout is set to 7 seconds" do
+        let(:options) { {timeout: 5, open_timeout: 7} }
+
+        its(:open_timeout) { should == 7 }
+        its(:read_timeout) { should == 5 }
+
+        it "should override the timeout option" do
+          http = mock("http", null_object: true)
+          http.should_receive(:open_timeout=).twice
+          http.should_receive(:read_timeout=)
+          Net::HTTP.stub(new: http)
+          adapter.connection
+        end
+      end
+
+      context "when debug_output" do
+        let(:http) { Net::HTTP.new(uri) }
+        before do
+          Net::HTTP.stub(new: http)
+        end
+
+        context "is set to $stderr" do
+          let(:options) { {debug_output: $stderr} }
+          it "has debug output set" do
+            http.should_receive(:set_debug_output).with($stderr)
+            adapter.connection
+          end
+        end
+
+        context "is not provided" do
+          it "does not set_debug_output" do
+            http.should_not_receive(:set_debug_output)
+            adapter.connection
+          end
+        end
+      end
+
+      context 'when providing proxy address and port' do
+        let(:options) { {http_proxyaddr: '1.2.3.4', http_proxyport: 8080} }
+
+        it { should be_a_proxy }
+        its(:proxy_address) { should == '1.2.3.4' }
+        its(:proxy_port) { should == 8080 }
+
+        context 'as well as proxy user and password' do
+          let(:options) do
+            {http_proxyaddr: '1.2.3.4', http_proxyport: 8080,
+             http_proxyuser: 'user', http_proxypass: 'pass'}
+          end
+          its(:proxy_user) { should == 'user' }
+          its(:proxy_pass) { should == 'pass' }
+        end
+      end
+
+      context 'when not providing a proxy address' do
+        let(:uri) { URI 'http://proxytest.com' }
+
+        it "does not pass any proxy parameters to the connection" do
+          http = Net::HTTP.new("proxytest.com")
+          Net::HTTP.should_receive(:new).once.with("proxytest.com", 80).and_return(http)
+          adapter.connection
+        end
+      end
+
+      context 'when providing a local bind address and port' do
+        let(:options) { {local_host: "127.0.0.1", local_port: 12345 } }
+
+        its(:local_host) { should == '127.0.0.1' }
+        its(:local_port) { should == 12345 }
+      end if RUBY_VERSION >= '2.0'
+
+      context "when providing PEM certificates" do
+        let(:pem) { :pem_contents }
+        let(:options) { {pem: pem, pem_password: "password"} }
+
+        context "when scheme is https" do
+          let(:uri) { URI 'https://google.com' }
+          let(:cert) { mock("OpenSSL::X509::Certificate") }
+          let(:key) { mock("OpenSSL::PKey::RSA") }
+
+          before do
+            OpenSSL::X509::Certificate.should_receive(:new).with(pem).and_return(cert)
+            OpenSSL::PKey::RSA.should_receive(:new).with(pem, "password").and_return(key)
+          end
+
+          it "uses the provided PEM certificate" do
+            subject.cert.should == cert
+            subject.key.should == key
+          end
+
+          it "will verify the certificate" do
+            subject.verify_mode.should == OpenSSL::SSL::VERIFY_PEER
+          end
+          
+          context "when options include verify_peer=false" do
+            let(:options) { {pem: pem, pem_password: "password", verify_peer: false} }
+            
+            it "should not verify the certificate" do
+              subject.verify_mode.should == OpenSSL::SSL::VERIFY_NONE
+            end
+          end
+        end
+
+        context "when scheme is not https" do
+          let(:uri) { URI 'http://google.com' }
+          let(:http) { Net::HTTP.new(uri) }
+
+          before do
+            Net::HTTP.stub(new: http)
+            OpenSSL::X509::Certificate.should_not_receive(:new).with(pem)
+            OpenSSL::PKey::RSA.should_not_receive(:new).with(pem, "password")
+            http.should_not_receive(:cert=)
+            http.should_not_receive(:key=)
+          end
+
+          it "has no PEM certificate " do
+            subject.cert.should be_nil
+            subject.key.should be_nil
+          end
+        end
+      end
+
+      context "when providing PKCS12 certificates" do
+        let(:p12) { :p12_contents }
+        let(:options) { {p12: p12, p12_password: "password"} }
+
+        context "when scheme is https" do
+          let(:uri) { URI 'https://google.com' }
+          let(:pkcs12) { mock("OpenSSL::PKCS12", certificate: cert, key: key) }
+          let(:cert) { mock("OpenSSL::X509::Certificate") }
+          let(:key) { mock("OpenSSL::PKey::RSA") }
+
+          before do
+            OpenSSL::PKCS12.should_receive(:new).with(p12, "password").and_return(pkcs12)
+          end
+
+          it "uses the provided P12 certificate " do
+            subject.cert.should == cert
+            subject.key.should == key
+          end
+
+          it "will verify the certificate" do
+            subject.verify_mode.should == OpenSSL::SSL::VERIFY_PEER
+          end
+          
+          context "when options include verify_peer=false" do
+            let(:options) { {p12: p12, p12_password: "password", verify_peer: false} }
+            
+            it "should not verify the certificate" do
+              subject.verify_mode.should == OpenSSL::SSL::VERIFY_NONE
+            end
+          end
+        end
+
+        context "when scheme is not https" do
+          let(:uri) { URI 'http://google.com' }
+          let(:http) { Net::HTTP.new(uri) }
+
+          before do
+            Net::HTTP.stub(new: http)
+            OpenSSL::PKCS12.new.should_not_receive(:new).with(p12, "password")
+            http.should_not_receive(:cert=)
+            http.should_not_receive(:key=)
+          end
+
+          it "has no PKCS12 certificate " do
+            subject.cert.should be_nil
+            subject.key.should be_nil
+          end
+        end
+      end
+    end
+  end
+end

data/spec/httparty/cookie_hash_spec.rb

@@ -0,0 +1,83 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
+
+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")
+        @cookie_hash.length.should 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")
+      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
+      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")
+      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=='
+      end
+    end
+
+    describe 'with other class' do
+      it "should error" do
+        lambda {
+          @cookie_hash.add_cookies(Array.new)
+        }.should raise_error
+      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
+      @s.should match(/foo=bar/)
+      @s.should match(/rofl=copter/)
+      @s.should 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=\//)
+    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=\//)
+    end
+  end
+end

data/spec/httparty/exception_spec.rb

@@ -0,0 +1,23 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe HTTParty::Error do
+  subject { described_class }
+
+  its(:ancestors) { should include(StandardError) }
+
+  describe HTTParty::UnsupportedFormat do
+    its(:ancestors) { should include(HTTParty::Error) }
+  end
+  
+  describe HTTParty::UnsupportedURIScheme do
+    its(:ancestors) { should include(HTTParty::Error) }
+  end
+
+  describe HTTParty::ResponseError do
+    its(:ancestors) { should include(HTTParty::Error) }
+  end
+
+  describe HTTParty::RedirectionTooDeep do
+    its(:ancestors) { should include(HTTParty::ResponseError) }
+  end
+end

data/spec/httparty/logger/apache_logger_spec.rb

@@ -0,0 +1,41 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+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") }
+  let(:request_time) { Time.new.strftime("%Y-%m-%d %H:%M:%S %z") }
+
+  before do
+    subject.current_time = request_time
+    logger_double.should_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 }
+        )
+        response_double.stub(:[]).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_logger_spec.rb

@@ -0,0 +1,18 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+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(
+          /\[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

@@ -0,0 +1,22 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+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
+    end
+
+    it "defaults format to :apache" do
+      logger_double = double()
+      subject.build(logger_double, nil, nil).should 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)
+    end
+  end
+end