httparty 0.8.0 → 0.9.0

data/spec/httparty/response_spec.rb

@@ -9,7 +9,7 @@ describe HTTParty::Response do
     @response_object.stub(:body => "{foo:'bar'}")
     @response_object['last-modified'] = @last_modified
     @response_object['content-length'] = @content_length
-    @parsed_response = {"foo" => "bar"}
+    @parsed_response = lambda { {"foo" => "bar"} }
     @response = HTTParty::Response.new(@request_object, @response_object, @parsed_response)
   end
 
@@ -51,17 +51,42 @@ describe HTTParty::Response do
   end
 
   it "should send missing methods to delegate" do
-    response = HTTParty::Response.new(@request_object, @response_object, {'foo' => 'bar'})
+    response = HTTParty::Response.new(@request_object, @response_object, @parsed_response)
     response['foo'].should == 'bar'
   end
-  
-  it "should respond_to? methods it supports" do
-    response = HTTParty::Response.new(@request_object, @response_object, {'foo' => 'bar'})
+
+  it "response to request" do
+    response = HTTParty::Response.new(@request_object, @response_object, @parsed_response)
+    response.respond_to?(:request).should be_true
+  end
+
+  it "responds to response" do
+    response = HTTParty::Response.new(@request_object, @response_object, @parsed_response)
+    response.respond_to?(:response).should be_true
+  end
+
+  it "responds to body" do
+    response = HTTParty::Response.new(@request_object, @response_object, @parsed_response)
+    response.respond_to?(:body).should be_true
+  end
+
+  it "responds to headers" do
+    response = HTTParty::Response.new(@request_object, @response_object, @parsed_response)
+    response.respond_to?(:headers).should be_true
+  end
+
+  it "responds to parsed_response" do
+    response = HTTParty::Response.new(@request_object, @response_object, @parsed_response)
     response.respond_to?(:parsed_response).should be_true
   end
 
+  it "responds to anything parsed_response responds to" do
+    response = HTTParty::Response.new(@request_object, @response_object, @parsed_response)
+    response.respond_to?(:[]).should be_true
+  end
+
   it "should be able to iterate if it is array" do
-    response = HTTParty::Response.new(@request_object, @response_object, [{'foo' => 'bar'}, {'foo' => 'baz'}])
+    response = HTTParty::Response.new(@request_object, @response_object, lambda { [{'foo' => 'bar'}, {'foo' => 'baz'}] })
     response.size.should == 2
     expect {
       response.each { |item| }
@@ -89,22 +114,11 @@ describe HTTParty::Response do
     end
   end
 
-  xit "should allow hashes to be accessed with dot notation" do
-    response = HTTParty::Response.new(@request_object, {'foo' => 'bar'}, "{foo:'bar'}", 200, 'OK')
-    response.foo.should == 'bar'
-  end
-
-  xit "should allow nested hashes to be accessed with dot notation" do
-    response = HTTParty::Response.new(@request_object, {'foo' => {'bar' => 'baz'}}, "{foo: {bar:'baz'}}", 200, 'OK')
-    response.foo.should == {'bar' => 'baz'}
-    response.foo.bar.should == 'baz'
-  end
-
   describe "semantic methods for response codes" do
     def response_mock(klass)
-      r = klass.new('', '', '')
-      r.stub(:body)
-      r
+      response = klass.new('', '', '')
+      response.stub(:body)
+      response
     end
 
     context "major codes" do
@@ -190,4 +204,11 @@ describe HTTParty::Response do
       end
     end
   end
+
+  describe "headers" do
+    it "can initialize without headers" do
+      headers = HTTParty::Response::Headers.new
+      headers.should == {}
+    end
+  end
 end

data/spec/httparty/ssl_spec.rb

@@ -3,18 +3,18 @@ require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
 describe HTTParty::Request do
   context "SSL certificate verification" do
     before do
-      FakeWeb.allow_net_connect = true    # enable network connections just for this test
+      FakeWeb.allow_net_connect = true
     end
 
     after do
-      FakeWeb.allow_net_connect = false   # Restore allow_net_connect value for testing
+      FakeWeb.allow_net_connect = false
     end
 
-    it "should work with when no trusted CA list is specified" do
+    it "should work when no trusted CA list is specified" do
       ssl_verify_test(nil, nil, "selfsigned.crt").should == {'success' => true}
     end
 
-    it "should work with when no trusted CA list is specified, even with a bogus hostname" do
+    it "should work when no trusted CA list is specified, even with a bogus hostname" do
       ssl_verify_test(nil, nil, "bogushost.crt").should == {'success' => true}
     end
 
@@ -25,8 +25,14 @@ describe HTTParty::Request do
     it "should work when using ssl_ca_file with a certificate authority" do
       ssl_verify_test(:ssl_ca_file, "ca.crt", "server.crt").should == {'success' => true}
     end
+
     it "should work when using ssl_ca_path with a certificate authority" do
-      ssl_verify_test(:ssl_ca_path, ".", "server.crt").should == {'success' => true}
+      http = Net::HTTP.new('www.google.com', 443, nil, nil, nil, nil)
+      response = stub(Net::HTTPResponse, :[] => '', :body => '', :to_hash => {})
+      http.stub(:request).and_return(response)
+      Net::HTTP.should_receive(:new).with('www.google.com', 443, nil, nil, nil, nil).and_return(http)
+      http.should_receive(:ca_path=).with('/foo/bar')
+      HTTParty.get('https://www.google.com', :ssl_ca_path => '/foo/bar')
     end
 
     it "should fail when using ssl_ca_file and the server uses an unrecognized certificate authority" do
@@ -34,6 +40,7 @@ describe HTTParty::Request do
         ssl_verify_test(:ssl_ca_file, "ca.crt", "selfsigned.crt")
       end.should raise_error(OpenSSL::SSL::SSLError)
     end
+
     it "should fail when using ssl_ca_path and the server uses an unrecognized certificate authority" do
       lambda do
         ssl_verify_test(:ssl_ca_path, ".", "selfsigned.crt")
@@ -45,6 +52,7 @@ describe HTTParty::Request do
         ssl_verify_test(:ssl_ca_file, "ca.crt", "bogushost.crt")
       end.should raise_error(OpenSSL::SSL::SSLError)
     end
+
     it "should fail when using ssl_ca_path and the server uses a bogus hostname" do
       lambda do
         ssl_verify_test(:ssl_ca_path, ".", "bogushost.crt")

data/spec/httparty_spec.rb

@@ -10,6 +10,7 @@ describe HTTParty do
     before do
       Kernel.stub(:warn)
     end
+
     it "warns with a deprecation message" do
       Kernel.should_receive(:warn).with("Deprecated: Use HTTParty::Parser::SupportedFormats")
       HTTParty::AllowedFormats
@@ -19,9 +20,8 @@ describe HTTParty do
       HTTParty::AllowedFormats.should == HTTParty::Parser::SupportedFormats
     end
   end
-  
-  describe "pem" do
 
+  describe "pem" do
     it 'should set the pem content' do
       @klass.pem 'PEM-CONTENT'
       @klass.default_options[:pem].should == 'PEM-CONTENT'
@@ -36,7 +36,29 @@ describe HTTParty do
       @klass.pem 'PEM-CONTENT', 'PASSWORD'
       @klass.default_options[:pem_password].should == 'PASSWORD'
     end
+  end
+
+  describe 'ssl_version' do
+    it 'should set the ssl_version content' do
+      @klass.ssl_version :SSLv3
+      @klass.default_options[:ssl_version].should == :SSLv3
+    end
+  end
+
+  describe 'http_proxy' do
+    it 'should set the address' do
+      @klass.http_proxy 'proxy.foo.com', 80
+      options = @klass.default_options
+      options[:http_proxyaddr].should == 'proxy.foo.com'
+      options[:http_proxyport].should == 80
+    end
 
+    it 'should set the proxy user and pass when they are provided' do
+      @klass.http_proxy 'proxy.foo.com', 80, 'user', 'pass'
+      options = @klass.default_options
+      options[:http_proxyuser].should == 'user'
+      options[:http_proxypass].should == 'pass'
+    end
   end
 
   describe "base uri" do
@@ -88,6 +110,11 @@ describe HTTParty do
       HTTParty.normalize_base_uri(uri)
       uri.should == 'http://api.foobar.com'
     end
+
+    it "should not treat uri's with a port of 4430 as ssl" do
+      uri = HTTParty.normalize_base_uri('http://api.foo.com:4430/v1')
+      uri.should == 'http://api.foo.com:4430/v1'
+    end
   end
 
   describe "headers" do
@@ -306,6 +333,38 @@ describe HTTParty do
     end
   end
 
+  describe "connection_adapter" do
+    let(:uri) { 'http://google.com/api.json' }
+    let(:connection_adapter) { mock('CustomConnectionAdapter') }
+
+    it "should set the connection_adapter" do
+      @klass.connection_adapter connection_adapter
+      @klass.default_options[:connection_adapter].should be connection_adapter
+    end
+
+    it "should set the connection_adapter_options when provided" do
+      options = {:foo => :bar}
+      @klass.connection_adapter connection_adapter, options
+      @klass.default_options[:connection_adapter_options].should be options
+    end
+
+    it "should not set the connection_adapter_options when not provided" do
+      @klass.connection_adapter connection_adapter
+      @klass.default_options[:connection_adapter_options].should be_nil
+    end
+
+    it "should process a request with a connection from the adapter" do
+      connection_adapter_options = {:foo => :bar}
+      connection_adapter.should_receive(:call) do |u,o|
+        o[:connection_adapter_options].should == connection_adapter_options
+        HTTParty::ConnectionAdapter.call(u,o)
+      end.with(URI.parse(uri), kind_of(Hash))
+      FakeWeb.register_uri(:get, uri, :body => 'stuff')
+      @klass.connection_adapter connection_adapter, connection_adapter_options
+      @klass.get(uri).should == 'stuff'
+    end
+  end
+
   describe "format" do
     it "should allow xml" do
       @klass.format :xml
@@ -417,6 +476,12 @@ describe HTTParty do
       end.should raise_error(HTTParty::RedirectionTooDeep) {|e| e.response.body.should == 'first redirect'}
     end
 
+    it "should fail with redirected PATCH" do
+      lambda do
+        @klass.patch('/foo', :no_follow => true)
+      end.should raise_error(HTTParty::RedirectionTooDeep) {|e| e.response.body.should == 'first redirect'}
+    end
+
     it "should fail with redirected DELETE" do
       lambda do
         @klass.delete('/foo', :no_follow => true)
@@ -505,6 +570,14 @@ describe HTTParty do
       @parent.default_options.should == {:basic_auth => {:username => 'user', :password => 'password'}}
     end
 
+    it "doesn't modify hashes in the parent's default options" do
+      @parent.headers 'Accept' => 'application/json'
+      @child1.headers 'Accept' => 'application/xml'
+
+      @parent.default_options[:headers].should == {'Accept' => 'application/json'}
+      @child1.default_options[:headers].should == {'Accept' => 'application/xml'}
+    end
+
     it "inherits default_cookies from the parent class" do
       @parent.cookies 'type' => 'chocolate_chip'
       @child1.default_cookies.should == {"type" => "chocolate_chip"}
@@ -546,6 +619,15 @@ describe HTTParty do
       HTTParty.get('http://www.google.com').should == file_fixture('google.html')
     end
 
+    it "should be able to get chunked html" do
+      chunks = ["Chunk1", "Chunk2", "Chunk3", "Chunk4"]
+      stub_chunked_http_response_with(chunks)
+
+      HTTParty.get('http://www.google.com') do |fragment|
+        chunks.should include(fragment)
+      end.should == chunks.join
+    end
+
     it "should be able parse response type json automatically" do
       stub_http_response_with('twitter.json')
       tweets = HTTParty.get('http://twitter.com/statuses/public_timeline.json')

data/spec/spec.opts

@@ -1,3 +1,2 @@
 --colour
---format specdoc
 --backtrace

data/spec/spec_helper.rb

@@ -13,10 +13,18 @@ Dir[File.expand_path(File.join(File.dirname(__FILE__),'support','**','*.rb'))].e
 Spec::Runner.configure do |config|
   config.include HTTParty::StubResponse
   config.include HTTParty::SSLTestHelper
+
   config.before(:suite) do
     FakeWeb.allow_net_connect = false
   end
+
   config.after(:suite) do
     FakeWeb.allow_net_connect = true
   end
 end
+
+Spec::Matchers.define :use_ssl do
+  match do |connection|
+    connection.use_ssl?
+  end
+end

data/spec/support/ssl_test_helper.rb

@@ -1,25 +1,47 @@
+require 'pathname'
+
 module HTTParty
   module SSLTestHelper
     def ssl_verify_test(mode, ca_basename, server_cert_filename)
-      test_server = nil
+      options = {
+        :format  => :json,
+        :timeout => 30,
+      }
+
+      if mode
+        ca_path = File.expand_path("../../fixtures/ssl/generated/#{ca_basename}", __FILE__)
+        raise ArgumentError.new("#{ca_path} does not exist") unless File.exist?(ca_path)
+        options[mode] = ca_path
+      end
+
       begin
-        # Start an HTTPS server
         test_server = SSLTestServer.new(
             :rsa_key => File.read(File.expand_path("../../fixtures/ssl/generated/server.key", __FILE__)),
-            :cert => File.read(File.expand_path("../../fixtures/ssl/generated/#{server_cert_filename}", __FILE__)))
+            :cert    => File.read(File.expand_path("../../fixtures/ssl/generated/#{server_cert_filename}", __FILE__)))
+
         test_server.start
 
-        # Build a request
         if mode
           ca_path = File.expand_path("../../fixtures/ssl/generated/#{ca_basename}", __FILE__)
           raise ArgumentError.new("#{ca_path} does not exist") unless File.exist?(ca_path)
-          return HTTParty.get("https://localhost:#{test_server.port}/", :format => :json, :timeout=>30, mode => ca_path)
+          return HTTParty.get("https://localhost:#{test_server.port}/", :format => :json, :timeout => 30, mode => ca_path)
         else
-          return HTTParty.get("https://localhost:#{test_server.port}/", :format => :json, :timeout=>30)
+          return HTTParty.get("https://localhost:#{test_server.port}/", :format => :json, :timeout => 30)
         end
       ensure
         test_server.stop if test_server
       end
+
+      test_server = SSLTestServer.new({
+        :rsa_key => path.join('server.key').read,
+        :cert    => path.join(server_cert_filename).read,
+      })
+
+      test_server.start
+
+      HTTParty.get("https://localhost:#{test_server.port}/", options)
+    ensure
+      test_server.stop if test_server
     end
   end
 end

data/spec/support/ssl_test_server.rb

@@ -10,26 +10,30 @@ class SSLTestServer
   attr_reader :port
 
   def initialize(options={})
-    @ctx = OpenSSL::SSL::SSLContext.new
-    @ctx.cert = OpenSSL::X509::Certificate.new(options[:cert])
-    @ctx.key = OpenSSL::PKey::RSA.new(options[:rsa_key])
+    @ctx             = OpenSSL::SSL::SSLContext.new
+    @ctx.cert        = OpenSSL::X509::Certificate.new(options[:cert])
+    @ctx.key         = OpenSSL::PKey::RSA.new(options[:rsa_key])
     @ctx.verify_mode = OpenSSL::SSL::VERIFY_NONE   # Don't verify client certificate
-    @port = options[:port] || 0
-    @thread = nil
-    @stopping_mutex = Mutex.new
-    @stopping = false
+    @port            = options[:port] || 0
+    @thread          = nil
+    @stopping_mutex  = Mutex.new
+    @stopping        = false
   end
 
   def start
     @raw_server = TCPServer.new(@port)
+
     if @port == 0
       @port = Socket::getnameinfo(@raw_server.getsockname, Socket::NI_NUMERICHOST|Socket::NI_NUMERICSERV)[1].to_i
     end
+
     @ssl_server = OpenSSL::SSL::SSLServer.new(@raw_server, @ctx)
+
     @stopping_mutex.synchronize{
       return if @stopping
       @thread = Thread.new{ thread_main }
     }
+
     nil
   end
 
@@ -46,24 +50,31 @@ class SSLTestServer
     def thread_main
       until @stopping_mutex.synchronize{ @stopping }
         (rr,ww,ee) = select([@ssl_server.to_io], nil, nil, 0.1)
+
         next unless rr && rr.include?(@ssl_server.to_io)
+
         socket = @ssl_server.accept
+
         Thread.new{
           header = []
+
           until (line = socket.readline).rstrip.empty?
             header << line
           end
 
-          socket.write <<'EOF'.gsub(/\r\n/n, "\n").gsub(/\n/n, "\r\n")
+          response =<<EOF
 HTTP/1.1 200 OK
 Connection: close
 Content-Type: application/json; charset=UTF-8
 
 {"success":true}
 EOF
+
+          socket.write(response.gsub(/\r\n/n, "\n").gsub(/\n/n, "\r\n"))
           socket.close
       }
       end
+
       @ssl_server.close
     end
 end

data/spec/support/stub_response.rb

@@ -13,6 +13,19 @@ module HTTParty
       HTTParty::Request.should_receive(:new).and_return(http_request)
     end
 
+    def stub_chunked_http_response_with(chunks)
+      response = Net::HTTPResponse.new("1.1", 200, nil)
+      response.stub(:chunked_data).and_return(chunks)
+      def response.read_body(&block)
+        @body || chunked_data.each(&block)
+      end
+
+      http_request = HTTParty::Request.new(Net::HTTP::Get, 'http://localhost', :format => "html")
+      http_request.stub_chain(:http, :request).and_yield(response).and_return(response)
+
+      HTTParty::Request.should_receive(:new).and_return(http_request)
+    end
+
     def stub_response(body, code = 200)
       @request.options[:base_uri] ||= 'http://localhost'
       unless defined?(@http) && @http