arachni-typhoeus 0.2.0

data/spec/typhoeus/request_spec.rb

@@ -0,0 +1,276 @@
+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
+
+  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
+  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 => "hi"}, :headers => {:foo => "bar"})
+      response.code.should == 200
+      json = JSON.parse(response.body)
+      json["REQUEST_METHOD"].should == "POST"
+      json["rack.request.query_hash"]["q"].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 "takes cache_timeout as an option" do
+    Typhoeus::Request.new("http://localhost:3000", :cache_timeout => 60).cache_timeout.should == 60
+  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,151 @@
+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 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 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
+
+    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

data/spec/typhoeus/utils_spec.rb

@@ -0,0 +1,22 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Typhoeus::Utils do
+  # Taken from Rack 1.2.1
+  describe "#escape" do
+    it "should escape correctly" do
+      Typhoeus::Utils.escape("fo<o>bar").should == "fo%3Co%3Ebar"
+      Typhoeus::Utils.escape("a space").should == "a+space"
+      Typhoeus::Utils.escape("q1!2\"'w$5&7/z8)?\\").
+        should == "q1%212%22%27w%245%267%2Fz8%29%3F%5C"
+    end
+
+    it "should escape correctly for multibyte characters" do
+      matz_name = "\xE3\x81\xBE\xE3\x81\xA4\xE3\x82\x82\xE3\x81\xA8".unpack("a*")[0] # Matsumoto
+      matz_name.force_encoding("UTF-8") if matz_name.respond_to? :force_encoding
+      Typhoeus::Utils.escape(matz_name).should == '%E3%81%BE%E3%81%A4%E3%82%82%E3%81%A8'
+      matz_name_sep = "\xE3\x81\xBE\xE3\x81\xA4 \xE3\x82\x82\xE3\x81\xA8".unpack("a*")[0] # Matsu moto
+      matz_name_sep.force_encoding("UTF-8") if matz_name_sep.respond_to? :force_encoding
+      Typhoeus::Utils.escape(matz_name_sep).should == '%E3%81%BE%E3%81%A4+%E3%82%82%E3%81%A8'
+    end
+  end
+end