httparty 0.6.1 → 0.7.0

data/spec/httparty/response_spec.rb

@@ -4,13 +4,27 @@ describe HTTParty::Response do
   before do
     @last_modified = Date.new(2010, 1, 15).to_s
     @content_length = '1024'
-    @response_object = {'foo' => 'bar'}
+    @request_object = HTTParty::Request.new Net::HTTP::Get, '/'
     @response_object = Net::HTTPOK.new('1.1', 200, 'OK')
     @response_object.stub(:body => "{foo:'bar'}")
     @response_object['last-modified'] = @last_modified
     @response_object['content-length'] = @content_length
     @parsed_response = {"foo" => "bar"}
-    @response = HTTParty::Response.new(@response_object, @parsed_response)
+    @response = HTTParty::Response.new(@request_object, @response_object, @parsed_response)
+  end
+
+  describe ".underscore" do
+    it "works with one capitalized word" do
+      HTTParty::Response.underscore("Accepted").should == "accepted"
+    end
+
+    it "works with titlecase" do
+      HTTParty::Response.underscore("BadGateway").should == "bad_gateway"
+    end
+
+    it "works with all caps" do
+      HTTParty::Response.underscore("OK").should == "ok"
+    end
   end
 
   describe "initialization" do
@@ -32,17 +46,17 @@ describe HTTParty::Response do
   end
 
   it "returns response headers" do
-    response = HTTParty::Response.new(@response_object, @parsed_response)
+    response = HTTParty::Response.new(@request_object, @response_object, @parsed_response)
     response.headers.should == {'last-modified' => [@last_modified], 'content-length' => [@content_length]}
   end
 
   it "should send missing methods to delegate" do
-    response = HTTParty::Response.new(@response_object, {'foo' => 'bar'})
+    response = HTTParty::Response.new(@request_object, @response_object, {'foo' => 'bar'})
     response['foo'].should == 'bar'
   end
 
   it "should be able to iterate if it is array" do
-    response = HTTParty::Response.new(@response_object, [{'foo' => 'bar'}, {'foo' => 'baz'}])
+    response = HTTParty::Response.new(@request_object, @response_object, [{'foo' => 'bar'}, {'foo' => 'baz'}])
     response.size.should == 2
     expect {
       response.each { |item| }
@@ -50,20 +64,20 @@ describe HTTParty::Response do
   end
 
   it "allows headers to be accessed by mixed-case names in hash notation" do
-    response = HTTParty::Response.new(@response_object, @parsed_response)
+    response = HTTParty::Response.new(@request_object, @response_object, @parsed_response)
     response.headers['Content-LENGTH'].should == @content_length
   end
 
   it "returns a comma-delimited value when multiple values exist" do
     @response_object.add_field 'set-cookie', 'csrf_id=12345; path=/'
     @response_object.add_field 'set-cookie', '_github_ses=A123CdE; path=/'
-    response = HTTParty::Response.new(@response_object, @parsed_response)
+    response = HTTParty::Response.new(@request_object, @response_object, @parsed_response)
     response.headers['set-cookie'].should == "csrf_id=12345; path=/, _github_ses=A123CdE; path=/"
   end
 
   # Backwards-compatibility - previously, #headers returned a Hash
   it "responds to hash methods" do
-    response = HTTParty::Response.new(@response_object, @parsed_response)
+    response = HTTParty::Response.new(@request_object, @response_object, @parsed_response)
     hash_methods = {}.methods - response.headers.methods
     hash_methods.each do |method_name|
       response.headers.respond_to?(method_name).should be_true
@@ -71,13 +85,104 @@ describe HTTParty::Response do
   end
 
   xit "should allow hashes to be accessed with dot notation" do
-    response = HTTParty::Response.new({'foo' => 'bar'}, "{foo:'bar'}", 200, 'OK')
+    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({'foo' => {'bar' => 'baz'}}, "{foo: {bar:'baz'}}", 200, 'OK')
+    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
+    end
+
+    context "major codes" do
+      it "is information" do
+        net_response = response_mock(Net::HTTPInformation)
+        response = HTTParty::Response.new(@request_object, net_response, '')
+        response.information?.should be_true
+      end
+
+      it "is success" do
+        net_response = response_mock(Net::HTTPSuccess)
+        response = HTTParty::Response.new(@request_object, net_response, '')
+        response.success?.should be_true
+      end
+
+      it "is redirection" do
+        net_response = response_mock(Net::HTTPRedirection)
+        response = HTTParty::Response.new(@request_object, net_response, '')
+        response.redirection?.should be_true
+      end
+
+      it "is client error" do
+        net_response = response_mock(Net::HTTPClientError)
+        response = HTTParty::Response.new(@request_object, net_response, '')
+        response.client_error?.should be_true
+      end
+
+      it "is server error" do
+        net_response = response_mock(Net::HTTPServerError)
+        response = HTTParty::Response.new(@request_object, net_response, '')
+        response.server_error?.should be_true
+      end
+    end
+
+    context "for specific codes" do
+      SPECIFIC_CODES = {
+        :accepted?                        => Net::HTTPAccepted,
+        :bad_gateway?                     => Net::HTTPBadGateway,
+        :bad_request?                     => Net::HTTPBadRequest,
+        :conflict?                        => Net::HTTPConflict,
+        :continue?                        => Net::HTTPContinue,
+        :created?                         => Net::HTTPCreated,
+        :expectation_failed?              => Net::HTTPExpectationFailed,
+        :forbidden?                       => Net::HTTPForbidden,
+        :found?                           => Net::HTTPFound,
+        :gateway_time_out?                => Net::HTTPGatewayTimeOut,
+        :gone?                            => Net::HTTPGone,
+        :internal_server_error?           => Net::HTTPInternalServerError,
+        :length_required?                 => Net::HTTPLengthRequired,
+        :method_not_allowed?              => Net::HTTPMethodNotAllowed,
+        :moved_permanently?               => Net::HTTPMovedPermanently,
+        :multiple_choice?                 => Net::HTTPMultipleChoice,
+        :no_content?                      => Net::HTTPNoContent,
+        :non_authoritative_information?   => Net::HTTPNonAuthoritativeInformation,
+        :not_acceptable?                  => Net::HTTPNotAcceptable,
+        :not_found?                       => Net::HTTPNotFound,
+        :not_implemented?                 => Net::HTTPNotImplemented,
+        :not_modified?                    => Net::HTTPNotModified,
+        :ok?                              => Net::HTTPOK,
+        :partial_content?                 => Net::HTTPPartialContent,
+        :payment_required?                => Net::HTTPPaymentRequired,
+        :precondition_failed?             => Net::HTTPPreconditionFailed,
+        :proxy_authentication_required?   => Net::HTTPProxyAuthenticationRequired,
+        :request_entity_too_large?        => Net::HTTPRequestEntityTooLarge,
+        :request_time_out?                => Net::HTTPRequestTimeOut,
+        :request_uri_too_long?            => Net::HTTPRequestURITooLong,
+        :requested_range_not_satisfiable? => Net::HTTPRequestedRangeNotSatisfiable,
+        :reset_content?                   => Net::HTTPResetContent,
+        :see_other?                       => Net::HTTPSeeOther,
+        :service_unavailable?             => Net::HTTPServiceUnavailable,
+        :switch_protocol?                 => Net::HTTPSwitchProtocol,
+        :temporary_redirect?              => Net::HTTPTemporaryRedirect,
+        :unauthorized?                    => Net::HTTPUnauthorized,
+        :unsupported_media_type?          => Net::HTTPUnsupportedMediaType,
+        :use_proxy?                       => Net::HTTPUseProxy,
+        :version_not_supported?           => Net::HTTPVersionNotSupported
+      }.each do |method, klass|
+        it "responds to #{method}" do
+          net_response = response_mock(klass)
+          response = HTTParty::Response.new(@request_object, net_response, '')
+          response.__send__(method).should be_true
+        end
+      end
+    end
+  end
 end

data/spec/httparty/ssl_spec.rb

@@ -0,0 +1,54 @@
+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
+    end
+
+    after do
+      FakeWeb.allow_net_connect = false   # Restore allow_net_connect value for testing
+    end
+
+    it "should work with 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
+      ssl_verify_test(nil, nil, "bogushost.crt").should == {'success' => true}
+    end
+
+    it "should work when using ssl_ca_file with a self-signed CA" do
+      ssl_verify_test(:ssl_ca_file, "selfsigned.crt", "selfsigned.crt").should == {'success' => true}
+    end
+
+    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}
+    end
+
+    it "should fail when using ssl_ca_file and the server uses an unrecognized certificate authority" do
+      lambda 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")
+      end.should raise_error(OpenSSL::SSL::SSLError)
+    end
+
+    it "should fail when using ssl_ca_file and the server uses a bogus hostname" do
+      lambda 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")
+      end.should raise_error(OpenSSL::SSL::SSLError)
+    end
+  end
+end

data/spec/httparty_spec.rb

@@ -1,11 +1,5 @@
 require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
 
-class CustomParser
-  def self.parse(body)
-    return {:sexy => true}
-  end
-end
-
 describe HTTParty do
   before(:each) do
     @klass = Class.new
@@ -25,6 +19,25 @@ describe HTTParty do
       HTTParty::AllowedFormats.should == HTTParty::Parser::SupportedFormats
     end
   end
+  
+  describe "pem" do
+
+    it 'should set the pem content' do
+      @klass.pem 'PEM-CONTENT'
+      @klass.default_options[:pem].should == 'PEM-CONTENT'
+    end
+
+    it "should set the password to nil if it's not provided" do
+      @klass.pem 'PEM-CONTENT'
+      @klass.default_options[:pem_password].should be_nil
+    end
+
+    it 'should set the password' do
+      @klass.pem 'PEM-CONTENT', 'PASSWORD'
+      @klass.default_options[:pem_password].should == 'PASSWORD'
+    end
+
+  end
 
   describe "base uri" do
     before(:each) do
@@ -47,7 +60,14 @@ describe HTTParty do
     end
   end
 
-  describe "#normalize_base_uri" do
+  describe ".disable_rails_query_string_format" do
+    it "sets the query string normalizer to HTTParty::Request::NON_RAILS_QUERY_STRING_NORMALIZER" do
+      @klass.disable_rails_query_string_format
+      @klass.default_options[:query_string_normalizer].should == HTTParty::Request::NON_RAILS_QUERY_STRING_NORMALIZER
+    end
+  end
+
+  describe ".normalize_base_uri" do
     it "should add http if not present for non ssl requests" do
       uri = HTTParty.normalize_base_uri('api.foobar.com')
       uri.should == 'http://api.foobar.com'
@@ -241,6 +261,12 @@ describe HTTParty do
   end
 
   describe "parser" do
+    class CustomParser
+      def self.parse(body)
+        return {:sexy => true}
+      end
+    end
+
     let(:parser) do
       Proc.new{ |data, format| CustomParser.parse(data) }
     end
@@ -346,6 +372,26 @@ describe HTTParty do
     end
   end
 
+  describe ".follow_redirects" do
+    it "sets follow redirects to true by default" do
+      @klass.follow_redirects
+      @klass.default_options[:follow_redirects].should be_true
+    end
+
+    it "sets the follow_redirects option to false" do
+      @klass.follow_redirects false
+      @klass.default_options[:follow_redirects].should be_false
+    end
+  end
+
+  describe ".query_string_normalizer" do
+    it "sets the query_string_normalizer option" do
+      normalizer = proc {}
+      @klass.query_string_normalizer normalizer
+      @klass.default_options[:query_string_normalizer].should == normalizer
+    end
+  end
+
   describe "with explicit override of automatic redirect handling" do
     before do
       @request = HTTParty::Request.new(Net::HTTP::Get, 'http://api.foo.com/v1', :format => :xml, :no_follow => true)

data/spec/spec_helper.rb

@@ -10,6 +10,7 @@ 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

data/spec/support/ssl_test_helper.rb

@@ -0,0 +1,25 @@
+module HTTParty
+  module SSLTestHelper
+    def ssl_verify_test(mode, ca_basename, server_cert_filename)
+      test_server = nil
+      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__)))
+        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)
+        else
+          return HTTParty.get("https://localhost:#{test_server.port}/", :format => :json, :timeout=>30)
+        end
+      ensure
+        test_server.stop if test_server
+      end
+    end
+  end
+end

data/spec/support/ssl_test_server.rb

@@ -0,0 +1,69 @@
+require 'openssl'
+require 'socket'
+require 'thread'
+
+# NOTE: This code is garbage.  It probably has deadlocks, it might leak
+# threads, and otherwise cause problems in a real system.  It's really only
+# intended for testing HTTParty.
+class SSLTestServer
+  attr_accessor :ctx    # SSLContext object
+  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.verify_mode = OpenSSL::SSL::VERIFY_NONE   # Don't verify client certificate
+    @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
+
+  def stop
+    @stopping_mutex.synchronize{
+      return if @stopping
+      @stopping = true
+    }
+    @thread.join
+  end
+
+  private
+
+    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")
+HTTP/1.1 200 OK
+Connection: close
+Content-Type: application/json; charset=UTF-8
+
+{"success":true}
+EOF
+          socket.close
+      }
+      end
+      @ssl_server.close
+    end
+end

data/spec/support/stub_response.rb

@@ -8,16 +8,16 @@ module HTTParty
       response.stub!(:body).and_return(data)
 
       http_request = HTTParty::Request.new(Net::HTTP::Get, 'http://localhost', :format => format)
-      http_request.stub!(:perform_actual_request).and_return(response)
+      http_request.stub_chain(:http, :request).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
         @http = Net::HTTP.new('localhost', 80)
         @request.stub!(:http).and_return(@http)
-        @request.stub!(:uri).and_return(URI.parse("http://foo.com/foobar"))
       end
 
       response = Net::HTTPResponse::CODE_TO_OBJ[code.to_s].new("1.1", code, body)