httparty 0.8.0 → 0.9.0

data/lib/httparty/response/headers.rb

@@ -0,0 +1,31 @@
+module HTTParty
+  class Response #:nodoc:
+    class Headers
+      include ::Net::HTTPHeader
+
+      def initialize(header = {})
+        @header = header
+      end
+
+      def ==(other)
+        @header == other
+      end
+
+      def inspect
+        @header.inspect
+      end
+
+      def method_missing(name, *args, &block)
+        if @header.respond_to?(name)
+          @header.send(name, *args, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to?(method)
+        super || @header.respond_to?(method)
+      end
+    end
+  end
+end

data/lib/httparty/version.rb

@@ -1,3 +1,3 @@
 module HTTParty
-  VERSION = "0.8.0"
+  VERSION = "0.9.0"
 end

data/spec/httparty/connection_adapter_spec.rb

@@ -0,0 +1,206 @@
+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 "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 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 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 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
+        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
+    end
+  end
+end

data/spec/httparty/cookie_hash_spec.rb

@@ -6,7 +6,6 @@ describe HTTParty::CookieHash do
   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")
@@ -29,7 +28,7 @@ describe HTTParty::CookieHash do
         @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")
@@ -37,7 +36,7 @@ describe HTTParty::CookieHash do
         @cookie_hash[:foo].should eql("tar")
       end
     end
-    
+
     describe 'with other class' do
       it "should error" do
         lambda {
@@ -61,7 +60,7 @@ describe HTTParty::CookieHash do
       @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

data/spec/httparty/net_digest_auth_spec.rb

@@ -14,10 +14,35 @@ describe Net::HTTPHeader::DigestAuthenticator do
   end
 
 
+  context "with an opaque value in the response header" do
+    before do
+      @digest = setup_digest({
+        'www-authenticate' => 'Digest realm="myhost@testrealm.com", opaque="solid"'
+      })
+    end
+
+    it "should set opaque" do
+      authorization_header.should include(%Q(opaque="solid"))
+    end
+  end
+
+  context "without an opaque valid in the response header" do
+    before do
+      @digest = setup_digest({
+        'www-authenticate' => 'Digest realm="myhost@testrealm.com"'
+      })  
+    end
+
+    it "should not set opaque" do
+      authorization_header.should_not include(%Q(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"'})
+      @digest = setup_digest({
+        'www-authenticate' => 'Digest realm="myhost@testrealm.com", nonce="NONCE", qop="auth"',
+      })
     end
 
     it "should set prefix" do
@@ -41,13 +66,11 @@ describe Net::HTTPHeader::DigestAuthenticator do
     end
 
     it "should set nonce-count" do
-      authorization_header.should include(%Q(nc="0"))
+      authorization_header.should include(%Q(nc="00000001"))
     end
 
     it "should set response" do
-      request_digest =
-        "md5(md5(Mufasa:myhost@testrealm.com:Circle Of Life)" +
-        ":NONCE:0:md5(deadbeef):auth:md5(GET:/dir/index.html))"
+      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}"))
     end
   end
@@ -55,8 +78,9 @@ describe Net::HTTPHeader::DigestAuthenticator do
 
   context "with unspecified quality of protection (qop)" do
     before do
-      @digest = setup_digest({'www-authenticate' =>
-        'Digest realm="myhost@testrealm.com", nonce="NONCE"'})
+      @digest = setup_digest({
+        'www-authenticate' => 'Digest realm="myhost@testrealm.com", nonce="NONCE"',
+      })
     end
 
     it "should set prefix" do
@@ -84,9 +108,7 @@ describe Net::HTTPHeader::DigestAuthenticator do
     end
 
     it "should set response" do
-      request_digest =
-        "md5(md5(Mufasa:myhost@testrealm.com:Circle Of Life)" +
-        ":NONCE:md5(GET:/dir/index.html))"
+      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}"))
     end
   end

data/spec/httparty/parser_spec.rb

@@ -87,6 +87,16 @@ describe HTTParty::Parser do
       @parser.stub(:body => nil)
       @parser.parse.should be_nil
     end
+
+    it "returns nil for a 'null' body" do
+      @parser.stub(:body => "null")
+      @parser.parse.should be_nil
+    end
+
+    it "returns nil for a body with spaces only" do
+      @parser.stub(:body => "   ")
+      @parser.parse.should be_nil
+    end
   end
 
   describe "#supports_format?" do
@@ -135,6 +145,12 @@ describe HTTParty::Parser do
     end
 
     it "parses json with MultiJson" do
+      MultiJson.should_receive(:load).with('body')
+      subject.send(:json)
+    end
+
+    it "uses MultiJson.decode if MultiJson does not respond to adapter" do
+      MultiJson.should_receive(:respond_to?).with(:adapter).and_return(false)
       MultiJson.should_receive(:decode).with('body')
       subject.send(:json)
     end

data/spec/httparty/request_spec.rb

@@ -45,6 +45,17 @@ describe HTTParty::Request do
       request = HTTParty::Request.new(Net::HTTP::Get, 'http://google.com', :parser => my_parser)
       request.parser.should == my_parser
     end
+
+    it "sets connection_adapter to HTTPParty::ConnectionAdapter" do
+      request = HTTParty::Request.new(Net::HTTP::Get, 'http://google.com')
+      request.connection_adapter.should == HTTParty::ConnectionAdapter
+    end
+
+    it "sets connection_adapter to the optional connection_adapter" do
+      my_adapter = lambda {}
+      request = HTTParty::Request.new(Net::HTTP::Get, 'http://google.com', :connection_adapter => my_adapter)
+      request.connection_adapter.should == my_adapter
+    end
   end
 
   describe "#format" do
@@ -86,7 +97,7 @@ describe HTTParty::Request do
     end
 
     it "should use digest auth when configured" do
-      FakeWeb.register_uri(:head, "http://api.foo.com/v1",
+      FakeWeb.register_uri(:get, "http://api.foo.com/v1",
         :www_authenticate => 'Digest realm="Log Viewer", qop="auth", nonce="2CA0EC6B0E126C4800E56BA0C0003D3C", opaque="5ccc069c403ebaf9f0171e9517f40e41", stale=false')
 
       @request.options[:digest_auth] = {:username => 'foobar', :password => 'secret'}
@@ -95,6 +106,17 @@ describe HTTParty::Request do
       raw_request = @request.instance_variable_get(:@raw_request)
       raw_request.instance_variable_get(:@header)['Authorization'].should_not be_nil
     end
+
+    it "should use the right http method for digest authentication" do
+      @post_request = HTTParty::Request.new(Net::HTTP::Post, 'http://api.foo.com/v1', :format => :xml)
+      FakeWeb.register_uri(:post, "http://api.foo.com/v1", {})
+
+      http = @post_request.send(:http)
+      @post_request.should_receive(:http).and_return(http)
+      http.should_not_receive(:head).and_return({'www-authenticate' => nil})
+      @post_request.options[:digest_auth] = {:username => 'foobar', :password => 'secret'}
+      @post_request.send(:setup_raw_request)
+    end
   end
 
   describe "#uri" do
@@ -134,106 +156,12 @@ describe HTTParty::Request do
   end
 
   describe 'http' do
-    it "should use ssl for port 443" do
-      request = HTTParty::Request.new(Net::HTTP::Get, 'https://api.foo.com/v1:443')
-      request.send(:http).use_ssl?.should == true
-    end
-
-    it 'should not use ssl for port 80' do
-      request = HTTParty::Request.new(Net::HTTP::Get, 'http://foobar.com')
-      request.send(:http).use_ssl?.should == false
-    end
-
-    it "uses ssl for https scheme with default port" do
-      request = HTTParty::Request.new(Net::HTTP::Get, 'https://foobar.com')
-      request.send(:http).use_ssl?.should == true
-    end
-
-    it "uses ssl for https scheme regardless of port" do
-      request = HTTParty::Request.new(Net::HTTP::Get, 'https://foobar.com:123456')
-      request.send(:http).use_ssl?.should == true
-    end
-
-    context "PEM certificates" do
-      before do
-        OpenSSL::X509::Certificate.stub(:new)
-        OpenSSL::PKey::RSA.stub(:new)
-      end
-
-      context "when scheme is https" do
-        before do
-          @request.stub!(:uri).and_return(URI.parse("https://google.com"))
-          pem = :pem_contents
-          @cert = mock("OpenSSL::X509::Certificate")
-          @key =  mock("OpenSSL::PKey::RSA")
-          OpenSSL::X509::Certificate.should_receive(:new).with(pem).and_return(@cert)
-          OpenSSL::PKey::RSA.should_receive(:new).with(pem, "password").and_return(@key)
-
-          @request.options[:pem] = pem
-          @request.options[:pem_password] = "password"
-          @pem_http = @request.send(:http)
-        end
-
-        it "should use a PEM certificate when provided" do
-          @pem_http.cert.should == @cert
-          @pem_http.key.should == @key
-        end
-
-        it "should verify the certificate when provided" do
-          @pem_http = @request.send(:http)
-          @pem_http.verify_mode.should == OpenSSL::SSL::VERIFY_PEER
-        end
-      end
-
-      context "when scheme is not https" do
-        it "does not assign a PEM" do
-          http = Net::HTTP.new('google.com')
-          http.should_not_receive(:cert=)
-          http.should_not_receive(:key=)
-          Net::HTTP.stub(:new => http)
-
-          request = HTTParty::Request.new(Net::HTTP::Get, 'http://google.com')
-          request.options[:pem] = :pem_contents
-          request.send(:http)
-        end
-      end
-
-      context "debugging" do
-        before do
-          @http = Net::HTTP.new('google.com')
-          Net::HTTP.stub(:new => @http)
-          @request = HTTParty::Request.new(Net::HTTP::Get, 'http://google.com')
-        end
-
-        it "calls #set_debug_output when the option is provided" do
-          @request.options[:debug_output] = $stderr
-          @http.should_receive(:set_debug_output).with($stderr)
-          @request.send(:http)
-        end
-
-        it "does not set_debug_output when the option is not provided" do
-          @http.should_not_receive(:set_debug_output)
-          @request.send(:http)
-        end
-      end
-    end
-
-    context "when setting timeout" do
-      it "does nothing if the timeout option is a string" do
-        http = mock("http", :null_object => true)
-        http.should_not_receive(:open_timeout=)
-        http.should_not_receive(:read_timeout=)
-        Net::HTTP.stub(:new => http)
-
-        request = HTTParty::Request.new(Net::HTTP::Get, 'https://foobar.com', {:timeout => "five seconds"})
-        request.send(:http)
-      end
-
-      it "sets the timeout to 5 seconds" do
-        @request.options[:timeout] = 5
-        @request.send(:http).open_timeout.should == 5
-        @request.send(:http).read_timeout.should == 5
-      end
+    it "should get a connection from the connection_adapter" do
+      http = Net::HTTP.new('google.com')
+      adapter = mock('adapter')
+      request = HTTParty::Request.new(Net::HTTP::Get, 'https://api.foo.com/v1:443', :connection_adapter => adapter)
+      adapter.should_receive(:call).with(request.uri, request.options).and_return(http)
+      request.send(:http).should be http
     end
   end
 
@@ -381,6 +309,16 @@ describe HTTParty::Request do
         resp.body.should == "<foo><bar>error</bar></foo>"
         resp['foo']['bar'].should == "error"
       end
+
+      it "parses response lazily so codes can be checked prior" do
+        stub_response 'not xml', 500
+        @request.options[:format] = :xml
+        lambda {
+          response = @request.perform
+          response.code.should == 500
+          response.body.should == 'not xml'
+        }.should_not raise_error
+      end
     end
   end
 
@@ -426,6 +364,11 @@ describe HTTParty::Request do
         @request.perform.should == {"hash" => {"foo" => "bar"}}
       end
 
+      it "should be handled by PATCH transparently" do
+        @request.http_method = Net::HTTP::Patch
+        @request.perform.should == {"hash" => {"foo" => "bar"}}
+      end
+
       it "should be handled by PUT transparently" do
         @request.http_method = Net::HTTP::Put
         @request.perform.should == {"hash" => {"foo" => "bar"}}
@@ -487,6 +430,40 @@ describe HTTParty::Request do
     end
   end
 
+  describe "#handle_deflation" do
+    context "context-encoding" do
+      before do
+        @request.options[:format] = :html
+        @last_response = mock()
+        @last_response.stub!(:body).and_return('')
+      end
+
+      it "should inflate the gzipped body with content-encoding: gzip" do
+        @last_response.stub!(:[]).with("content-encoding").and_return("gzip")
+        @request.stub!(:last_response).and_return(@last_response)
+        Zlib::GzipReader.should_receive(:new).and_return(StringIO.new(''))
+        @request.last_response.should_receive(:delete).with('content-encoding')
+        @request.send(:handle_deflation)
+      end
+
+      it "should inflate the gzipped body with content-encoding: x-gzip" do
+        @last_response.stub!(:[]).with("content-encoding").and_return("x-gzip")
+        @request.stub!(:last_response).and_return(@last_response)
+        Zlib::GzipReader.should_receive(:new).and_return(StringIO.new(''))
+        @request.last_response.should_receive(:delete).with('content-encoding')
+        @request.send(:handle_deflation)
+      end
+
+      it "should inflate the deflated body" do
+        @last_response.stub!(:[]).with("content-encoding").and_return("deflate")
+        @request.stub!(:last_response).and_return(@last_response)
+        Zlib::Inflate.should_receive(:inflate).and_return('')
+        @request.last_response.should_receive(:delete).with('content-encoding')
+        @request.send(:handle_deflation)
+      end
+    end
+  end
+
   context "with POST http method" do
     it "should raise argument error if query is not a hash" do
       lambda {