httparty 0.13.0 → 0.21.0

data/spec/httparty/connection_adapter_spec.rb

@@ -1,298 +0,0 @@
-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 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
-        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
-        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

@@ -1,83 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,26 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
-
-describe HTTParty::Logger::ApacheLogger do
-  describe "#format" do
-    it "formats a response in a style that resembles apache's access log" do
-      request_time = Time.new.strftime("%Y-%m-%d %H:%M:%S %z")
-      log_message = "[HTTParty] [#{request_time}] 302 \"GET http://my.domain.com/my_path\" - "
-
-      request_double  = double(
-        :http_method => Net::HTTP::Get,
-        :path => "http://my.domain.com/my_path"
-      )
-      response_double = double(
-        :code => 302,
-        :[]   => nil
-      )
-
-      logger_double = double
-      logger_double.should_receive(:info).with(log_message)
-
-      subject = described_class.new(logger_double, :info)
-      subject.current_time = request_time
-      subject.format(request_double, response_double)
-    end
-  end
-end

data/spec/httparty/logger/curl_logger_spec.rb

@@ -1,18 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

data/spec/httparty/net_digest_auth_spec.rb

@@ -1,152 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
-
-describe Net::HTTPHeader::DigestAuthenticator do
-  def setup_digest(response)
-    digest = Net::HTTPHeader::DigestAuthenticator.new("Mufasa",
-      "Circle Of Life", "GET", "/dir/index.html", response)
-    digest.stub(:random).and_return("deadbeef")
-    Digest::MD5.stub(:hexdigest) { |str| "md5(#{str})" }
-    digest
-  end
-
-  def authorization_header
-    @digest.authorization_header.join(", ")
-  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"',
-      })
-    end
-
-    it "should set prefix" do
-      authorization_header.should =~ /^Digest /
-    end
-
-    it "should set username" do
-      authorization_header.should include(%Q(username="Mufasa"))
-    end
-
-    it "should set digest-uri" do
-      authorization_header.should include(%Q(uri="/dir/index.html"))
-    end
-
-    it "should set qop" do
-      authorization_header.should include(%Q(qop="auth"))
-    end
-
-    it "should set cnonce" do
-      authorization_header.should include(%Q(cnonce="md5(deadbeef)"))
-    end
-
-    it "should set nonce-count" do
-      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:00000001:md5(deadbeef):auth:md5(GET:/dir/index.html))"
-      authorization_header.should include(%Q(response="#{request_digest}"))
-    end
-  end
-
-
-  context "with unspecified quality of protection (qop)" do
-    before do
-      @digest = setup_digest({
-        'www-authenticate' => 'Digest realm="myhost@testrealm.com", nonce="NONCE"',
-      })
-    end
-
-    it "should set prefix" do
-      authorization_header.should =~ /^Digest /
-    end
-
-    it "should set username" do
-      authorization_header.should include(%Q(username="Mufasa"))
-    end
-
-    it "should set digest-uri" do
-      authorization_header.should include(%Q(uri="/dir/index.html"))
-    end
-
-    it "should not set qop" do
-      authorization_header.should_not include(%Q(qop=))
-    end
-
-    it "should not set cnonce" do
-      authorization_header.should_not include(%Q(cnonce=))
-    end
-
-    it "should not set nonce-count" do
-      authorization_header.should_not include(%Q(nc=))
-    end
-
-    it "should set response" do
-      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
-
-  context "with multiple authenticate headers" do
-    before do
-      @digest = setup_digest({
-        'www-authenticate' => 'NTLM, Digest realm="myhost@testrealm.com", nonce="NONCE", qop="auth"',
-      })
-    end
-
-    it "should set prefix" do
-      authorization_header.should =~ /^Digest /
-    end
-
-    it "should set username" do
-      authorization_header.should include(%Q(username="Mufasa"))
-    end
-
-    it "should set digest-uri" do
-      authorization_header.should include(%Q(uri="/dir/index.html"))
-    end
-
-    it "should set qop" do
-      authorization_header.should include(%Q(qop="auth"))
-    end
-
-    it "should set cnonce" do
-      authorization_header.should include(%Q(cnonce="md5(deadbeef)"))
-    end
-
-    it "should set nonce-count" do
-      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:00000001:md5(deadbeef):auth:md5(GET:/dir/index.html))"
-      authorization_header.should include(%Q(response="#{request_digest}"))
-    end
-  end
-end