typhoeus 0.1.31 → 0.2.0

data/lib/typhoeus/normalized_header_hash.rb

@@ -0,0 +1,58 @@
+module Typhoeus
+  class NormalizedHeaderHash < ::Hash
+    def initialize(constructor = {})
+      if constructor.is_a?(Hash)
+        super
+        update(constructor)
+      else
+        super(constructor)
+      end
+    end
+
+    def fetch(key, *extras)
+      super(convert_key(key), *extras)
+    end
+
+    def key?(key)
+      super(convert_key(key))
+    end
+
+    [:include?, :has_key?, :member?].each do |method|
+      alias_method method, :key?
+    end
+
+    def [](key)
+      super(convert_key(key))
+    end
+
+    def []=(key, value)
+      super(convert_key(key), value)
+    end
+
+    def update(other_hash)
+      other_hash.each_pair do |key, value|
+        self[convert_key(key)] = value
+      end
+      self
+    end
+
+    alias_method :merge!, :update
+
+    def dup
+      self.class.new(self)
+    end
+
+    def merge(hash)
+      self.dup.update(hash)
+    end
+
+    def delete(key)
+      super(convert_key(key))
+    end
+
+  private
+    def convert_key(key)
+      key.to_s.split(/_|-/).map { |segment| segment.capitalize }.join("-")
+    end
+  end
+end

data/lib/typhoeus/request.rb

@@ -1,9 +1,15 @@
+require 'uri'
+
 module Typhoeus
   class Request
-    attr_accessor :method, :params, :body, :headers, :connect_timeout, :timeout, :user_agent, :response, :cache_timeout, :follow_location, :max_redirects, :proxy, :disable_ssl_peer_verification, :ssl_cert, :ssl_cert_type, :ssl_key, :ssl_key_type, :ssl_key_password, :ssl_cacert, :ssl_capath, :verbose, :username, :password,
-:auth_method
-
     attr_reader   :url
+    attr_writer   :headers
+    attr_accessor :method, :params, :body, :connect_timeout, :timeout,
+                  :user_agent, :response, :cache_timeout, :follow_location,
+                  :max_redirects, :proxy, :disable_ssl_peer_verification,
+                  :ssl_cert, :ssl_cert_type, :ssl_key, :ssl_key_type,
+                  :ssl_key_password, :ssl_cacert, :ssl_capath, :verbose,
+                  :username, :password, :auth_method, :user_agent
 
     # Initialize a new Request
     #
@@ -64,11 +70,18 @@ module Typhoeus
       else
         @url = @params ? "#{url}?#{params_string}" : url
       end
+
+      @parsed_uri = URI.parse(@url)
+
       @on_complete      = nil
       @after_complete   = nil
       @handled_response = nil
     end
 
+    def localhost?
+      %(localhost 127.0.0.1 0.0.0.0).include?(@parsed_uri.host)
+    end
+
     def host
       slash_location = @url.index('/', 8)
       if slash_location
@@ -88,12 +101,12 @@ module Typhoeus
       params.keys.sort { |a, b| a.to_s <=> b.to_s }.collect do |k|
         value = params[k]
         if value.is_a? Hash
-          value.keys.collect {|sk| Rack::Utils.escape("#{k}[#{sk}]") + "=" + Rack::Utils.escape(value[sk].to_s)}
+          value.keys.collect {|sk| Typhoeus::Utils.escape("#{k}[#{sk}]") + "=" + Typhoeus::Utils.escape(value[sk].to_s)}
         elsif value.is_a? Array
-          key = Rack::Utils.escape(k.to_s)
-          value.collect { |v| "#{key}=#{Rack::Utils.escape(v.to_s)}" }.join('&')
+          key = Typhoeus::Utils.escape(k.to_s)
+          value.collect { |v| "#{key}[]=#{Typhoeus::Utils.escape(v.to_s)}" }.join('&')
         else
-          "#{Rack::Utils.escape(k.to_s)}=#{Rack::Utils.escape(params[k].to_s)}"
+          "#{Typhoeus::Utils.escape(k.to_s)}=#{Typhoeus::Utils.escape(params[k].to_s)}"
         end
       end.flatten.join("&")
     end
@@ -122,7 +135,7 @@ module Typhoeus
     end
 
     def call_after_complete
-       @after_complete.call(@handled_response) if @after_complete
+      @after_complete.call(@handled_response) if @after_complete
     end
 
     def handled_response=(val)
@@ -133,6 +146,24 @@ module Typhoeus
       @handled_response || response
     end
 
+    def inspect
+      result = ":method => #{self.method.inspect},\n" <<
+               "\t:url => #{URI.parse(self.url).to_s}"
+      if self.body and !self.body.empty?
+        result << ",\n\t:body => #{self.body.inspect}"
+      end
+
+      if self.params and !self.params.empty?
+        result << ",\n\t:params => #{self.params.inspect}"
+      end
+
+      if self.headers and !self.headers.empty?
+        result << ",\n\t:headers => #{self.headers.inspect}"
+      end
+
+      result
+    end
+
     def cache_key
       Digest::SHA1.hexdigest(url)
     end

data/lib/typhoeus/response.rb

@@ -1,14 +1,17 @@
 module Typhoeus
   class Response
-    attr_accessor :request
+    attr_accessor :request, :mock
     attr_reader :code, :headers, :body, :time,
                 :requested_url, :requested_remote_method,
                 :requested_http_method, :start_time,
                 :effective_url
+    attr_writer :headers_hash
 
     def initialize(params = {})
       @code                  = params[:code]
-      @headers               = params[:headers]
+      @status_message        = params[:status_message]
+      @http_version          = params[:http_version]
+      @headers               = params[:headers] || ''
       @body                  = params[:body]
       @time                  = params[:time]
       @requested_url         = params[:requested_url]
@@ -16,28 +19,46 @@ module Typhoeus
       @start_time            = params[:start_time]
       @request               = params[:request]
       @effective_url         = params[:effective_url]
+      @mock                  = params[:mock] || false  # default
+      @headers_hash          = NormalizedHeaderHash.new(params[:headers_hash]) if params[:headers_hash]
+    end
+
+    # Returns true if this is a mock response.
+    def mock?
+      @mock
     end
 
     def headers_hash
-      headers.split("\n").map {|o| o.strip}.inject({}) do |hash, o|
-        if o.empty?
-          hash
-        else
-          i = o.index(":") || o.size
-          key = o.slice(0, i)
-          value = o.slice(i + 1, o.size)
-          value = value.strip unless value.nil?
-          if hash.has_key? key
-            hash[key] = [hash[key], value].flatten
+      @headers_hash ||= begin
+        headers.split("\n").map {|o| o.strip}.inject(Typhoeus::NormalizedHeaderHash.new) do |hash, o|
+          if o.empty? || o =~ /^HTTP\/[\d\.]+/
+            hash
           else
-            hash[key] = value
-          end
+            i = o.index(":") || o.size
+            key = o.slice(0, i)
+            value = o.slice(i + 1, o.size)
+            value = value.strip unless value.nil?
+            if hash.has_key? key
+              hash[key] = [hash[key], value].flatten
+            else
+              hash[key] = value
+            end
 
-          hash
+            hash
+          end
         end
       end
     end
 
+    def status_message
+      # http://rubular.com/r/eAr1oVYsVa
+      @status_message ||= first_header_line ? first_header_line[/\d{3} (.*)$/, 1].chomp : nil
+    end
+
+    def http_version
+      @http_version ||= first_header_line ? first_header_line[/HTTP\/(\S+)/, 1] : nil
+    end
+
     def success?
       @code >= 200 && @code < 300
     end
@@ -45,5 +66,11 @@ module Typhoeus
     def modified?
       @code != 304
     end
+
+    private
+
+      def first_header_line
+        @first_header_line ||= headers.split("\n").first
+      end
   end
 end

data/lib/typhoeus/utils.rb

@@ -0,0 +1,24 @@
+module Typhoeus
+  module Utils
+    # Taken from Rack::Utils, 1.2.1 to remove Rack dependency.
+    def escape(s)
+      s.to_s.gsub(/([^ a-zA-Z0-9_.-]+)/u) {
+        '%'+$1.unpack('H2'*bytesize($1)).join('%').upcase
+      }.tr(' ', '+')
+    end
+    module_function :escape
+
+    # Return the bytesize of String; uses String#size under Ruby 1.8 and
+    # String#bytesize under 1.9.
+    if ''.respond_to?(:bytesize)
+      def bytesize(string)
+        string.bytesize
+      end
+    else
+      def bytesize(string)
+        string.size
+      end
+    end
+    module_function :bytesize
+  end
+end

data/spec/spec_helper.rb

@@ -8,4 +8,4 @@ begin require "redgreen" unless ENV['TM_CURRENT_LINE']; rescue LoadError; end
 path = File.expand_path(File.dirname(__FILE__) + "/../lib/")
 $LOAD_PATH.unshift(path) unless $LOAD_PATH.include?(path)
 
-require "lib/typhoeus"
+require path + '/typhoeus'

data/spec/typhoeus/hydra_mock_spec.rb

@@ -0,0 +1,300 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe Typhoeus::HydraMock do
+  it "should mark all responses as mocks" do
+    response = Typhoeus::Response.new(:mock => false)
+    response.should_not be_mock
+
+    mock = Typhoeus::HydraMock.new("http://localhost", :get)
+    mock.and_return(response)
+
+    mock.response.should be_mock
+    response.should be_mock
+  end
+
+  describe "stubbing response values" do
+    before(:each) do
+      @stub = Typhoeus::HydraMock.new('http://localhost:3000', :get)
+    end
+
+    describe "with a single response" do
+      it "should always return that response" do
+        response = Typhoeus::Response.new
+        @stub.and_return(response)
+
+        5.times do
+          @stub.response.should == response
+        end
+      end
+    end
+
+    describe "with multiple responses" do
+      it "should return consecutive responses in the array, then keep returning the last one" do
+        responses = []
+        3.times do |i|
+          responses << Typhoeus::Response.new(:body => "response #{i}")
+        end
+
+        # Stub 3 consecutive responses.
+        @stub.and_return(responses)
+
+        0.upto(2) do |i|
+          @stub.response.should == responses[i]
+        end
+
+        5.times do
+          @stub.response.should == responses.last
+        end
+      end
+    end
+  end
+
+  describe "#matches?" do
+    describe "basic matching" do
+      it "should not match if the HTTP verbs are different" do
+        request = Typhoeus::Request.new("http://localhost:3000",
+                                        :method => :get)
+        mock = Typhoeus::HydraMock.new("http://localhost:3000", :post)
+        mock.matches?(request).should be_false
+      end
+    end
+
+    describe "matching on ports" do
+      it "should handle default port 80 sanely" do
+        mock = Typhoeus::HydraMock.new('http://www.example.com:80/', :get,
+                                       :headers => { 'user-agent' => 'test' })
+        request = Typhoeus::Request.new('http://www.example.com/',
+                                        :method => :get,
+                                        :user_agent => 'test')
+        mock.matches?(request).should be_true
+      end
+
+      it "should handle default port 443 sanely" do
+        mock = Typhoeus::HydraMock.new('https://www.example.com:443/', :get,
+                                       :headers => { 'user-agent' => 'test' })
+        request = Typhoeus::Request.new('https://www.example.com/',
+                                        :method => :get,
+                                        :user_agent => 'test')
+        mock.matches?(request).should be_true
+      end
+    end
+
+
+    describe "any HTTP verb" do
+      it "should match any verb" do
+        mock = Typhoeus::HydraMock.new("http://localhost:3000", :any,
+                                       :headers => { 'user-agent' => 'test' })
+        [:get, :post, :delete, :put].each do |verb|
+          request = Typhoeus::Request.new("http://localhost:3000",
+                                          :method => verb,
+                                          :user_agent => 'test')
+          mock.matches?(request).should be_true
+        end
+      end
+    end
+
+    describe "header matching" do
+      def request(options = {})
+        Typhoeus::Request.new("http://localhost:3000", options.merge(:method => :get))
+      end
+
+      def mock(options = {})
+        Typhoeus::HydraMock.new("http://localhost:3000", :get, options)
+      end
+
+      context 'when no :headers option is given' do
+        subject { mock }
+
+        it "matches regardless of whether or not the request has headers" do
+          subject.matches?(request(:headers => nil)).should be_true
+          subject.matches?(request(:headers => {})).should be_true
+          subject.matches?(request(:headers => { 'a' => 'b' })).should be_true
+        end
+      end
+
+      [nil, {}].each do |value|
+        context "for :headers => #{value.inspect}" do
+          subject { mock(:headers => value) }
+
+          it "matches when the request has no headers" do
+            subject.matches?(request(:headers => nil)).should be_true
+            subject.matches?(request(:headers => {})).should be_true
+          end
+
+          it "does not match when the request has headers" do
+            subject.matches?(request(:headers => { 'a' => 'b' })).should be_false
+          end
+        end
+      end
+
+      context 'for :headers => [a hash]' do
+        it 'does not match if the request has no headers' do
+          m = mock(:headers => { 'A' => 'B', 'C' => 'D' })
+
+          m.matches?(request).should be_false
+          m.matches?(request(:headers => nil)).should be_false
+          m.matches?(request(:headers => {})).should be_false
+        end
+
+        it 'does not match if the request lacks any of the given headers' do
+          mock(
+            :headers => { 'A' => 'B', 'C' => 'D' }
+          ).matches?(request(
+            :headers => { 'A' => 'B' }
+          )).should be_false
+        end
+
+        it 'does not match if any of the specified values are different from the request value' do
+          mock(
+            :headers => { 'A' => 'B', 'C' => 'D' }
+          ).matches?(request(
+            :headers => { 'A' => 'B', 'C' => 'E' }
+          )).should be_false
+        end
+
+        it 'matches if the given hash is exactly equal to the request headers' do
+          mock(
+            :headers => { 'A' => 'B', 'C' => 'D' }
+          ).matches?(request(
+            :headers => { 'A' => 'B', 'C' => 'D' }
+          )).should be_true
+        end
+
+        it 'matches even if the request has additional headers not specified in the mock' do
+          mock(
+            :headers => { 'A' => 'B', 'C' => 'D' }
+          ).matches?(request(
+            :headers => { 'A' => 'B', 'C' => 'D', 'E' => 'F' }
+          )).should be_true
+        end
+
+        it 'matches even if the casing of the header keys is different between the mock and request' do
+          mock(
+            :headers => { 'A' => 'B', 'c' => 'D' }
+          ).matches?(request(
+            :headers => { 'a' => 'B', 'C' => 'D' }
+          )).should be_true
+        end
+
+        it 'matches if the mocked values are regexes and match the request values' do
+          mock(
+            :headers => { 'A' => /foo/, }
+          ).matches?(request(
+            :headers => { 'A' => 'foo bar' }
+          )).should be_true
+        end
+
+        it 'does not match if the mocked values are regexes and do not match the request values' do
+          mock(
+            :headers => { 'A' => /foo/, }
+          ).matches?(request(
+            :headers => { 'A' => 'bar' }
+          )).should be_false
+        end
+
+        context 'when a header is specified as an array' do
+          it 'matches when the request header has the same array' do
+            mock(
+              :headers => { 'Accept' => ['text/html', 'text/plain'] }
+            ).matches?(request(
+              :headers => { 'Accept' => ['text/html', 'text/plain'] }
+            )).should be_true
+          end
+
+          it 'matches when the request header is a single value and the mock array has the same value' do
+            mock(
+              :headers => { 'Accept' => ['text/html'] }
+            ).matches?(request(
+              :headers => { 'Accept' => 'text/html' }
+            )).should be_true
+          end
+
+          it 'matches even when the request header array is ordered differently' do
+            mock(
+              :headers => { 'Accept' => ['text/html', 'text/plain'] }
+            ).matches?(request(
+              :headers => { 'Accept' => ['text/plain', 'text/html'] }
+            )).should be_true
+          end
+
+          it 'does not match when the request header array lacks a value' do
+            mock(
+              :headers => { 'Accept' => ['text/html', 'text/plain'] }
+            ).matches?(request(
+              :headers => { 'Accept' => ['text/plain'] }
+            )).should be_false
+          end
+
+          it 'does not match when the request header array has an extra value' do
+            mock(
+              :headers => { 'Accept' => ['text/html', 'text/plain'] }
+            ).matches?(request(
+              :headers => { 'Accept' => ['text/html', 'text/plain', 'application/xml'] }
+            )).should be_false
+          end
+
+          it 'does not match when the request header is not an array' do
+            mock(
+              :headers => { 'Accept' => ['text/html', 'text/plain'] }
+            ).matches?(request(
+              :headers => { 'Accept' => 'text/html' }
+            )).should be_false
+          end
+        end
+      end
+    end
+
+    describe "post body matching" do
+      it "should not bother matching on body if we don't turn the option on" do
+        request = Typhoeus::Request.new("http://localhost:3000",
+                                        :method => :get,
+                                        :user_agent => 'test',
+                                        :body => "fdsafdsa")
+        mock = Typhoeus::HydraMock.new("http://localhost:3000", :get,
+                                       :headers => { 'user-agent' => 'test' })
+        mock.matches?(request).should be_true
+      end
+
+      it "should match nil correctly" do
+        request = Typhoeus::Request.new("http://localhost:3000",
+                                        :method => :get,
+                                        :body => "fdsafdsa")
+        mock = Typhoeus::HydraMock.new("http://localhost:3000", :get,
+                                       :body => nil)
+        mock.matches?(request).should be_false
+      end
+
+      it "should not match if the bodies do not match" do
+        request = Typhoeus::Request.new("http://localhost:3000",
+                                        :method => :get,
+                                        :body => "ffdsadsafdsa")
+        mock = Typhoeus::HydraMock.new("http://localhost:3000", :get,
+                                       :body => 'fdsafdsa')
+        mock.matches?(request).should be_false
+      end
+
+      it "should match on optional body parameter" do
+        request = Typhoeus::Request.new("http://localhost:3000",
+                                        :method => :get,
+                                        :user_agent => 'test',
+                                        :body => "fdsafdsa")
+        mock = Typhoeus::HydraMock.new("http://localhost:3000", :get,
+                                       :body => 'fdsafdsa',
+                                       :headers => {
+                                         'User-Agent' => 'test'
+                                       })
+        mock.matches?(request).should be_true
+      end
+
+      it "should regex match" do
+        request = Typhoeus::Request.new("http://localhost:3000/whatever/fdsa",
+                                        :method => :get,
+                                        :user_agent => 'test')
+        mock = Typhoeus::HydraMock.new(/fdsa/, :get,
+                                       :headers => { 'user-agent' => 'test' })
+        mock.matches?(request).should be_true
+      end
+    end
+  end
+end
+