marnen-typhoeus 0.3.4

data/spec/typhoeus/request_spec.rb

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

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