typhoeus 0.3.3 → 0.4.0

data/spec/typhoeus/request_spec.rb

@@ -1,387 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Typhoeus::Request do
-  describe "#inspect" do
-    before(:each) do
-      @request = Typhoeus::Request.new('http://www.google.com/',
-                                       :body => "a=1&b=2",
-                                       :params => { :c => 'ok' },
-                                       :method => :get,
-                                       :headers => { 'Content-Type' => 'text/html' })
-    end
-
-    it "should dump out the URI" do
-      @request.inspect.should =~ /http:\/\/www\.google\.com/
-    end
-
-    it "should dump out the body" do
-      @request.inspect.should =~ /a=1&b=2/
-    end
-
-    it "should dump params" do
-      @request.inspect.should =~ /:c\s*=>\s*"ok"/
-    end
-
-    it "should dump the method" do
-      @request.inspect.should =~ /:get/
-    end
-
-    it "should dump out headers" do
-      @request.inspect.should =~ /"Content-Type"\s*=>\s*"text\/html"/
-    end
-  end
-
-  context "marshalling" do
-
-    let(:request) do
-      Typhoeus::Request.new("http://google.com")
-    end
-
-    describe "#marshal_dump" do
-      context "when an on_complete handler is defined" do
-
-        before do
-          request.on_complete {}
-        end
-
-        it "does not raise an error" do
-          lambda { Marshal.dump(request) }.should_not raise_error(TypeError)
-        end
-
-      end
-
-      context "when an after_complete handler is defined" do
-
-        before do
-          request.after_complete {}
-        end
-
-        it "does not raise an error" do
-          lambda { Marshal.dump(request) }.should_not raise_error(TypeError)
-        end
-
-      end
-
-    end
-
-    it "is reversible but exclude handlers" do
-      request.on_complete {}
-      request.after_complete {}
-
-      new_request = Marshal.load(Marshal.dump(request))
-
-      new_request.url.should == request.url
-      new_request.on_complete.should be_nil
-      new_request.after_complete.should be_nil
-    end
-
-  end
-
-  describe "#localhost?" do
-    %w(localhost 127.0.0.1 0.0.0.0).each do |host|
-      it "should be true for the #{host} host" do
-        req = Typhoeus::Request.new("http://#{host}")
-        req.should be_localhost
-      end
-    end
-
-    it "should be false for other domains" do
-      req = Typhoeus::Request.new("http://google.com")
-      req.should_not be_localhost
-    end
-  end
-
-  describe "#params_string" do
-    it "should dump a sorted string" do
-      request = Typhoeus::Request.new(
-        "http://google.com",
-        :params => {
-          'b' => 'fdsa',
-          'a' => 'jlk',
-          'c' => '789'
-        }
-      )
-
-      request.params_string.should == "a=jlk&b=fdsa&c=789"
-    end
-
-    it "should accept symboled keys" do
-      request = Typhoeus::Request.new('http://google.com',
-                                      :params => {
-                                        :b => 'fdsa',
-                                        :a => 'jlk',
-                                        :c => '789'
-                                      })
-      request.params_string.should == "a=jlk&b=fdsa&c=789"
-    end
-
-    it "should translate params with values that are arrays to the proper format" do
-      request = Typhoeus::Request.new('http://google.com',
-                                      :params => {
-                                        :a => ['789','2434']
-                                      })
-      request.params_string.should == "a=789&a=2434"
-    end
-
-    it "should allow the newer bracket notation for array params" do
-      request = Typhoeus::Request.new('http://google.com',
-                                      :params => {
-                                        "a[]" => ['789','2434']
-                                      })
-      request.params_string.should == "a%5B%5D=789&a%5B%5D=2434"
-    end
-
-    it "should nest arrays in hashes" do
-      request = Typhoeus::Request.new('http://google.com',
-                                      :params => {
-                                        :a => { :b => { :c => ['d','e'] } }
-                                      })
-      request.params_string.should == "a%5Bb%5D%5Bc%5D=d&a%5Bb%5D%5Bc%5D=e"
-    end
-
-    it "should translate nested params correctly" do
-      request = Typhoeus::Request.new('http://google.com',
-                                      :params => {
-                                        :a => { :b => { :c => 'd' } }
-                                      })
-      request.params_string.should == "a%5Bb%5D%5Bc%5D=d"
-    end
-  end
-
-  describe "quick request methods" do
-    it "can run a GET synchronously" do
-      response = Typhoeus::Request.get("http://localhost:3000", :params => {:q => "hi"}, :headers => {:foo => "bar"})
-      response.code.should == 200
-      JSON.parse(response.body)["REQUEST_METHOD"].should == "GET"
-    end
-
-    it "can run a POST synchronously" do
-      response = Typhoeus::Request.post("http://localhost:3000", :params => {:q => { :a => "hi" } }, :headers => {:foo => "bar"})
-      response.code.should == 200
-
-      json = JSON.parse(response.body)
-      json["REQUEST_METHOD"].should == "POST"
-      json["rack.request.form_hash"]["q"]["a"].should == "hi"
-    end
-
-    it "can run a PUT synchronously" do
-      response = Typhoeus::Request.put("http://localhost:3000", :params => {:q => "hi"}, :headers => {:foo => "bar"})
-      response.code.should == 200
-      JSON.parse(response.body)["REQUEST_METHOD"].should == "PUT"
-    end
-
-    it "can run a DELETE synchronously" do
-      response = Typhoeus::Request.delete("http://localhost:3000", :params => {:q => "hi"}, :headers => {:foo => "bar"})
-      response.code.should == 200
-      JSON.parse(response.body)["REQUEST_METHOD"].should == "DELETE"
-    end
-  end
-
-  it "takes url as the first argument" do
-    Typhoeus::Request.new("http://localhost:3000").url.should == "http://localhost:3000"
-  end
-
-  it "should parse the host from the url" do
-    Typhoeus::Request.new("http://localhost:3000/whatever?hi=foo").host.should == "http://localhost:3000"
-    Typhoeus::Request.new("http://localhost:3000?hi=foo").host.should == "http://localhost:3000"
-    Typhoeus::Request.new("http://localhost:3000").host.should == "http://localhost:3000"
-  end
-
-  it "takes method as an option" do
-    Typhoeus::Request.new("http://localhost:3000", :method => :get).method.should == :get
-  end
-
-  it "takes headers as an option" do
-    headers = {:foo => :bar}
-    request = Typhoeus::Request.new("http://localhost:3000", :headers => headers)
-    request.headers.should == headers
-  end
-
-  it "takes params as an option and adds them to the url" do
-    Typhoeus::Request.new("http://localhost:3000", :params => {:foo => "bar"}).url.should == "http://localhost:3000?foo=bar"
-  end
-
-  it "takes request body as an option" do
-    Typhoeus::Request.new("http://localhost:3000", :body => "whatever").body.should == "whatever"
-  end
-
-  it "takes timeout as an option" do
-    Typhoeus::Request.new("http://localhost:3000", :timeout => 10).timeout.should == 10
-  end
-
-  it "accepts a string for the timeout option" do
-    Typhoeus::Request.new("http://localhost:3000", :timeout => "150").timeout.should == 150
-  end
-
-  it "doesn't convert a nil timeout to an integer" do
-    Typhoeus::Request.new("http://localhost:3000", :timeout => nil).timeout.should_not == nil.to_i
-  end
-
-  it "doesn't convert an empty timeout to an integer" do
-    Typhoeus::Request.new("http://localhost:3000", :timeout => "").timeout.should_not == "".to_i
-  end
-
-  it "takes connect_timeout as an option" do
-    Typhoeus::Request.new("http://localhost:3000", :connect_timeout => 14).connect_timeout.should == 14
-  end
-
-  it "accepts a string for the connect_timeout option" do
-    Typhoeus::Request.new("http://localhost:3000", :connect_timeout => "420").connect_timeout.should == 420
-  end
-
-  it "doesn't convert a nil connect_timeout to an integer" do
-    Typhoeus::Request.new("http://localhost:3000", :connect_timeout => nil).connect_timeout.should_not == nil.to_i
-  end
-
-  it "doesn't convert an empty connect_timeout to an integer" do
-    Typhoeus::Request.new("http://localhost:3000", :connect_timeout => "").connect_timeout.should_not == "".to_i
-  end
-
-  it "takes cache_timeout as an option" do
-    Typhoeus::Request.new("http://localhost:3000", :cache_timeout => 60).cache_timeout.should == 60
-  end
-
-  it "accepts a string for the cache_timeout option" do
-    Typhoeus::Request.new("http://localhost:3000", :cache_timeout => "42").cache_timeout.should == 42
-  end
-
-  it "doesn't convert a nil cache_timeout to an integer" do
-    Typhoeus::Request.new("http://localhost:3000", :cache_timeout => nil).cache_timeout.should_not == nil.to_i
-  end
-
-  it "doesn't convert an empty cache_timeout to an integer" do
-    Typhoeus::Request.new("http://localhost:3000", :cache_timeout => "").cache_timeout.should_not == "".to_i
-  end
-
-  it "takes follow_location as an option" do
-    Typhoeus::Request.new("http://localhost:3000", :follow_location => true).follow_location.should == true
-  end
-
-  it "takes max_redirects as an option" do
-    Typhoeus::Request.new("http://localhost:3000", :max_redirects => 10).max_redirects.should == 10
-  end
-
-  it "has the associated response object" do
-    request = Typhoeus::Request.new("http://localhost:3000")
-    request.response = :foo
-    request.response.should == :foo
-  end
-
-  it "has an on_complete handler that is called when the request is completed" do
-    request = Typhoeus::Request.new("http://localhost:3000")
-    foo = nil
-    request.on_complete do |response|
-      foo = response
-    end
-    request.response = :bar
-    request.call_handlers
-    foo.should == :bar
-  end
-
-  it "has an on_complete setter" do
-    foo = nil
-    proc = Proc.new {|response| foo = response}
-    request = Typhoeus::Request.new("http://localhost:3000")
-    request.on_complete = proc
-    request.response = :bar
-    request.call_handlers
-    foo.should == :bar
-  end
-
-  it "stores the handled response that is the return value from the on_complete block" do
-    request = Typhoeus::Request.new("http://localhost:3000")
-    request.on_complete do |response|
-      "handled"
-    end
-    request.response = :bar
-    request.call_handlers
-    request.handled_response.should == "handled"
-  end
-
-  it "has an after_complete handler that recieves what on_complete returns" do
-    request = Typhoeus::Request.new("http://localhost:3000")
-    request.on_complete do |response|
-      "handled"
-    end
-    good = nil
-    request.after_complete do |object|
-      good = object == "handled"
-    end
-    request.call_handlers
-    good.should be_true
-  end
-
-  it "has an after_complete setter" do
-    request = Typhoeus::Request.new("http://localhost:3000")
-    request.on_complete do |response|
-      "handled"
-    end
-    good = nil
-    proc = Proc.new {|object| good = object == "handled"}
-    request.after_complete = proc
-
-    request.call_handlers
-    good.should be_true
-  end
-
-  describe "time info" do
-    it "should have time" do
-      response = Typhoeus::Request.get("http://localhost:3000")
-      response.time.should > 0
-    end
-
-    it "should have connect time" do
-      response = Typhoeus::Request.get("http://localhost:3000")
-      response.connect_time.should > 0
-    end
-
-    it "should have app connect time" do
-      response = Typhoeus::Request.get("http://localhost:3000")
-      response.app_connect_time.should  > 0
-    end
-
-    it "should have start transfer time" do
-      response = Typhoeus::Request.get("http://localhost:3000")
-      response.start_transfer_time.should  > 0
-    end
-
-    it "should have pre-transfer time" do
-      response = Typhoeus::Request.get("http://localhost:3000")
-      response.pretransfer_time.should  > 0
-    end
-
-  end
-
-
-  describe "authentication" do
-
-    it "should allow to set username and password" do
-      auth = { :username => 'foo', :password => 'bar' }
-      e = Typhoeus::Request.get(
-        "http://localhost:3001/auth_basic/#{auth[:username]}/#{auth[:password]}",
-        auth
-      )
-      e.code.should == 200
-    end
-
-    it "should allow to set authentication method" do
-      auth = {
-        :username => 'username',
-        :password => 'password',
-        :auth_method => :ntlm
-      }
-      e = Typhoeus::Request.get(
-        "http://localhost:3001/auth_ntlm",
-        auth
-      )
-      e.code.should == 200
-    end
-
-  end
-
-  describe "retry" do
-    it "should take a retry option"
-    it "should count the number of times a request has failed"
-  end
-
-end

data/spec/typhoeus/response_spec.rb

@@ -1,192 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Typhoeus::Response do
-  describe "timed_out?" do
-    it "should return true if curl return code is 28" do
-      response = Typhoeus::Response.new(:curl_return_code => 28)
-      response.should be_timed_out
-    end
-
-    it "should return false for not 28" do
-      response = Typhoeus::Response.new(:curl_return_code => 14)
-      response.should_not be_timed_out
-    end
-  end
-
-  describe "initialize" do
-    it "should store headers_hash" do
-      response = Typhoeus::Response.new(:headers_hash => {})
-      response.headers_hash.should == {}
-    end
-
-    it "allows header access using a different casing of the header key" do
-      response = Typhoeus::Response.new(:headers_hash => { 'content-type' => 'text/html' } )
-      response.headers_hash['Content-Type'].should == 'text/html'
-    end
-
-    it "should store response_code" do
-      Typhoeus::Response.new(:code => 200).code.should == 200
-    end
-
-    it "should store status_message" do
-      Typhoeus::Response.new(:status_message => 'Not Found').status_message.should == 'Not Found'
-    end
-
-    it "should return nil for status_message if none is given and no header is given" do
-      Typhoeus::Response.new.status_message.should be_nil
-    end
-
-    it "should return nil for status_message if a message-less header is given" do
-      Typhoeus::Response.new(:headers => "HTTP/1.1 200\r\n").status_message.should == nil
-    end
-
-    it "should store http_version" do
-      Typhoeus::Response.new(:http_version => '1.1').http_version.should == '1.1'
-    end
-
-    it "should return nil for http version if none is given and no header is given" do
-      Typhoeus::Response.new.http_version.should be_nil
-    end
-    
-    it "should return nil for http version if an invalid or incomplete header is given" do
-      Typhoeus::Response.new(:headers => "HTTP foo/bar 200 OK\r\n").http_version.should == nil
-    end
-
-    it "should store response_headers" do
-      Typhoeus::Response.new(:headers => "a header!").headers.should == "a header!"
-    end
-    
-    it "should store response_body" do
-      Typhoeus::Response.new(:body => "a body!").body.should == "a body!"
-    end
-    
-    it "should store request_time" do
-      Typhoeus::Response.new(:time => 1.23).time.should == 1.23
-    end
-
-    it "should store requested_url" do
-      response = Typhoeus::Response.new(:requested_url => "http://test.com")
-      response.requested_url.should == "http://test.com"
-    end
-
-    it "should store requested_http_method" do
-      response = Typhoeus::Response.new(:requested_http_method => :delete)
-      response.requested_http_method.should == :delete
-    end
-
-    it "should store an associated request object" do
-      response = Typhoeus::Response.new(:request => "whatever")
-      response.request.should == "whatever"
-    end
-
-    it "should not default to be a mock response" do
-      response = Typhoeus::Response.new
-      response.should_not be_mock
-    end
-  end
-
-  describe "#mock?" do
-    it "should be true if it's a mock response" do
-      response = Typhoeus::Response.new(:mock => true)
-      response.should be_mock
-    end
-  end
-
-  describe "headers" do
-    it 'should return an empty hash from #headers_hash when no headers string is given' do
-      response = Typhoeus::Response.new.headers_hash.should == {}
-    end
-
-    context 'when the headers_hash is stubbed' do
-      after(:each) { Typhoeus::Hydra.clear_stubs }
-      let!(:orig_response) { Typhoeus::Request.get("http://localhost:3000/multiple-headers") }
-
-      it 'returns a properly formatted string built from the headers_hash, code, status_message and http_version' do
-        stub_response = Typhoeus::Response.new(
-          :code           => orig_response.code,
-          :headers_hash   => orig_response.headers_hash,
-          :status_message => orig_response.status_message,
-          :http_version   => orig_response.http_version
-        )
-
-        stub_response.headers.size.should == orig_response.headers.size
-
-        orig_header_lines = orig_response.headers.split("\n")
-        stub_header_lines = stub_response.headers.split("\n")
-
-        # HTTP version/status line should be identical
-        orig_header_lines.shift.should == stub_header_lines.shift
-
-        # "XSS" gets downcased, so we have to fix it here.
-        orig_header_lines.each { |line| line.sub!('XSS', 'Xss') }
-
-        # we can't count on the header order being identical since ruby hashes are not always ordered
-        orig_header_lines.should =~ stub_header_lines
-      end
-
-      it 'returns a valid header string even with the code, status message and http_version are not stubbed' do
-        response = Typhoeus::Response.new(:headers_hash => orig_response.headers_hash)
-        response.headers.should =~ /Content-Type/
-      end
-    end
-
-    describe "basic parsing" do
-      before(:all) do
-        @response = Typhoeus::Response.new(:headers => "HTTP/1.1 200 OK\r\nContent-Type: text/html; charset=utf-8\r\nConnection: close\r\nStatus: 200\r\nX-Powered-By: Phusion Passenger (mod_rails/mod_rack) 2.2.9\r\nX-Cache: miss\r\nX-Runtime: 184\r\nETag: e001d08d9354ab7bc7c27a00163a3afa\r\nCache-Control: private, max-age=0, must-revalidate\r\nContent-Length: 4725\r\nSet-Cookie: _some_session=BAh7CDoGciIAOg9zZXNzaW9uX2lkIiU1OTQ2OTcwMjljMWM5ZTQwODU1NjQwYTViMmQxMTkxMjoGcyIKL2NhcnQ%3D--b4c4663932243090c961bb93d4ad5e4327064730; path=/; HttpOnly\r\nServer: nginx/0.6.37 + Phusion Passenger 2.2.4 (mod_rails/mod_rack)\r\nSet-Cookie: foo=bar; path=/;\r\nP3P: CP=\"NOI DSP COR NID ADMa OPTa OUR NOR\"\r\n\r\n")
-      end
-
-      it "can be accessed with lowercase keys" do
-        @response.headers_hash['content-type'].should == 'text/html; charset=utf-8'
-      end
-
-      it "can parse the headers into a hash" do
-        @response.headers_hash["Status"].should == "200"
-        @response.headers_hash["Set-Cookie"].should == ["_some_session=BAh7CDoGciIAOg9zZXNzaW9uX2lkIiU1OTQ2OTcwMjljMWM5ZTQwODU1NjQwYTViMmQxMTkxMjoGcyIKL2NhcnQ%3D--b4c4663932243090c961bb93d4ad5e4327064730; path=/; HttpOnly", "foo=bar; path=/;"]
-        @response.headers_hash["Content-Type"].should == "text/html; charset=utf-8"
-      end
-
-      it 'parses the status message' do
-        @response.status_message.should == 'OK'
-      end
-
-      it 'parses the HTTP version' do
-        @response.http_version.should == '1.1'
-      end
-
-      it 'parses all header keys except HTTP version declaration' do
-        @response.headers_hash.keys.should =~ %w[
-          X-Powered-By
-          P3p
-          X-Cache
-          Etag
-          X-Runtime
-          Content-Type
-          Content-Length
-          Server
-          Set-Cookie
-          Cache-Control
-          Connection
-          Status
-        ]
-      end
-    end
-
-    it "parses a header key that appears multiple times into an array" do
-      response = Typhoeus::Response.new(:headers => "HTTP/1.1 302 Found\r\nContent-Type: text/html; charset=utf-8\r\nConnection: close\r\nStatus: 302\r\nX-Powered-By: Phusion Passenger (mod_rails/mod_rack) 2.2.9\r\nLocation: http://mckenzie-greenholt1512.myshopify.com/cart\r\nX-Runtime: 22\r\nCache-Control: no-cache\r\nContent-Length: 114\r\nSet-Cookie: cart=8fdd6a828d9c89a737a52668be0cebaf; path=/; expires=Fri, 12-Mar-2010 18:30:19 GMT\r\nSet-Cookie: _session=BAh7CToPc2Vzc2lvbl9pZCIlZTQzMDQzMDg1YjI3MTQ4MzAzMTZmMWZmMWJjMTU1NmI6CWNhcnQiJThmZGQ2YTgyOGQ5Yzg5YTczN2E1MjY2OGJlMGNlYmFmOgZyIgA6BnMiDi9jYXJ0L2FkZA%3D%3D--6b0a699625caed9597580d8e9b6ca5f5e5954125; path=/; HttpOnly\r\nServer: nginx/0.6.37 + Phusion Passenger 2.2.4 (mod_rails/mod_rack)\r\nP3P: CP=\"NOI DSP COR NID ADMa OPTa OUR NOR\"\r\n\r\n")
-      response.headers_hash["Set-Cookie"].should include("cart=8fdd6a828d9c89a737a52668be0cebaf; path=/; expires=Fri, 12-Mar-2010 18:30:19 GMT")
-      response.headers_hash["Set-Cookie"].should include("_session=BAh7CToPc2Vzc2lvbl9pZCIlZTQzMDQzMDg1YjI3MTQ4MzAzMTZmMWZmMWJjMTU1NmI6CWNhcnQiJThmZGQ2YTgyOGQ5Yzg5YTczN2E1MjY2OGJlMGNlYmFmOgZyIgA6BnMiDi9jYXJ0L2FkZA%3D%3D--6b0a699625caed9597580d8e9b6ca5f5e5954125; path=/; HttpOnly")
-    end
-  end
-
-  describe "status checking" do
-    it "is successful if response code is 200-299" do
-      Typhoeus::Response.new(:code => 220).success?.should be
-      Typhoeus::Response.new(:code => 400).success?.should_not be
-    end
-
-    it "is not modified if the status code is 304" do
-      Typhoeus::Response.new(:code => 304).modified?.should_not be
-      Typhoeus::Response.new(:code => 200).modified?.should be
-    end
-  end
-end