typhoeus 0.1.31 → 0.2.0

data/.gitignore

@@ -1,2 +1,3 @@
 .*.sw?
 *.gem
+.bundle

data/CHANGELOG.markdown

@@ -1,3 +1,11 @@
+0.2.0
+------------
+* Fix warning in Request#headers from attr_accessor
+* Params with array values were not parsing into the format that rack expects
+[GH-39, smartocci]
+* Removed Rack as a dependency [GH-45]
+* Added integration hooks for VCR!
+
 0.1.31
 ------
 * Fixed bug in setting compression encoding [morhekil]

data/Gemfile

@@ -0,0 +1,9 @@
+source :rubygems
+
+group :test do
+  gem 'rspec', '1.3.1'
+  gem 'jeweler'
+  gem 'json'
+  gem 'sinatra'
+  gem 'diff-lcs'
+end

data/Gemfile.lock

@@ -0,0 +1,30 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.2)
+    gemcutter (0.6.1)
+    git (1.2.5)
+    jeweler (1.4.0)
+      gemcutter (>= 0.1.0)
+      git (>= 1.2.5)
+      rubyforge (>= 2.0.0)
+    json (1.4.6)
+    json_pure (1.4.6)
+    rack (1.2.1)
+    rspec (1.3.1)
+    rubyforge (2.0.4)
+      json_pure (>= 1.1.7)
+    sinatra (1.1.0)
+      rack (~> 1.1)
+      tilt (~> 1.1)
+    tilt (1.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  diff-lcs
+  jeweler
+  json
+  rspec (= 1.3.1)
+  sinatra

data/README.textile

@@ -51,7 +51,7 @@ require 'json'
 request = Typhoeus::Request.new("http://www.pauldix.net",
                                 :body          => "this is a request body",
                                 :method        => :post,
-                                :headers       => {:Accepts => "text/html"},
+                                :headers       => {:Accept => "text/html"},
                                 :timeout       => 100, # milliseconds
                                 :cache_timeout => 60, # seconds
                                 :params        => {:field1 => "a field"})

data/Rakefile

@@ -11,7 +11,6 @@ begin
     gemspec.email = "paul@pauldix.net"
     gemspec.homepage = "http://github.com/pauldix/typhoeus"
     gemspec.authors = ["Paul Dix"]
-    gemspec.add_dependency "rack"
     gemspec.add_development_dependency "rspec"
     gemspec.add_development_dependency "jeweler"
     gemspec.add_development_dependency "diff-lcs"

data/VERSION

@@ -1 +1 @@
-0.1.31
+0.2.0

data/ext/typhoeus/.gitignore

@@ -2,4 +2,5 @@ conftest.dSYM/*
 conftest.dSYM
 mkmf.log
 *.o
-native.bundle
+native.bundleMakefile
+*.bundle

data/lib/typhoeus.rb

@@ -1,7 +1,9 @@
 $LOAD_PATH.unshift(File.dirname(__FILE__)) unless $LOAD_PATH.include?(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.dirname(__FILE__) + "/../ext")
 
-require 'rack/utils'
 require 'digest/sha2'
+require 'typhoeus/utils'
+require 'typhoeus/normalized_header_hash'
 require 'typhoeus/easy'
 require 'typhoeus/multi'
 require 'typhoeus/native'
@@ -12,6 +14,7 @@ require 'typhoeus/remote_proxy_object'
 require 'typhoeus/response'
 require 'typhoeus/request'
 require 'typhoeus/hydra'
+require 'typhoeus/hydra_mock'
 
 module Typhoeus
   VERSION = File.read(File.dirname(__FILE__) + "/../VERSION").chomp

data/lib/typhoeus/easy.rb

@@ -179,12 +179,12 @@ module Typhoeus
       params_string = params.keys.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("&")
 

data/lib/typhoeus/hydra.rb

@@ -1,5 +1,13 @@
+require 'typhoeus/hydra/callbacks'
+require 'typhoeus/hydra/connect_options'
+require 'typhoeus/hydra/stubbing'
+
 module Typhoeus
   class Hydra
+    include ConnectOptions
+    include Stubbing
+    extend Callbacks
+
     def initialize(options = {})
       @memoize_requests = true
       @multi       = Multi.new
@@ -7,12 +15,13 @@ module Typhoeus
       initial_pool_size = options[:initial_pool_size] || 10
       @max_concurrency = options[:max_concurrency] || 200
       initial_pool_size.times { @easy_pool << Easy.new }
-      @stubs       = []
       @memoized_requests = {}
       @retrieved_from_cache = {}
       @queued_requests = []
       @running_requests = 0
-      @stubbed_request_count = 0
+
+      self.stubs = []
+      @active_stubs = []
     end
 
     def self.hydra
@@ -28,10 +37,6 @@ module Typhoeus
       @cache_getter = nil
     end
 
-    def clear_stubs
-      @stubs = []
-    end
-
     def fire_and_forget
       @queued_requests.each {|r| queue(r, false)}
       @multi.fire_and_forget
@@ -40,6 +45,10 @@ module Typhoeus
     def queue(request, obey_concurrency_limit = true)
       return if assign_to_stub(request)
 
+      # At this point, we are running over live HTTP. Make sure we haven't
+      # disabled live requests.
+      check_allow_net_connect!(request)
+
       if @running_requests >= @max_concurrency && obey_concurrency_limit
         @queued_requests << request
       else
@@ -62,14 +71,14 @@ module Typhoeus
     end
 
     def run
-      while @stubbed_request_count > 0
-        @stubs.each do |m|
-          while request = m.requests.shift
-            @stubbed_request_count -= 1
-            m.response.request = request
-            handle_request(request, m.response)
-          end
+      while !@active_stubs.empty?
+        m = @active_stubs.first
+        while request = m.requests.shift
+          response = m.response
+          response.request = request
+          handle_request(request, response)
         end
+        @active_stubs.delete(m)
       end
 
       @multi.perform
@@ -97,22 +106,6 @@ module Typhoeus
       @on_complete = proc
     end
 
-    def stub(method, url)
-      @stubs << HydraMock.new(url, method)
-      @stubs.last
-    end
-
-    def assign_to_stub(request)
-      m = @stubs.detect {|stub| stub.matches? request}
-      if m
-        m.add_request(request)
-        @stubbed_request_count += 1
-      else
-        nil
-      end
-    end
-    private :assign_to_stub
-
     def get_from_cache_or_queue(request)
       if @cache_getter
         val = @cache_getter.call(request)
@@ -188,6 +181,9 @@ module Typhoeus
     def handle_request(request, response, live_request = true)
       request.response = response
 
+      self.class.run_global_hooks_for(:after_request_before_on_complete,
+                                      request)
+
       if live_request && request.cache_timeout && @cache_setter
         @cache_setter.call(request)
       end
@@ -213,30 +209,4 @@ module Typhoeus
     end
     private :response_from_easy
   end
-
-  class HydraMock
-    attr_reader :url, :method, :response, :requests
-
-    def initialize(url, method)
-      @url      = url
-      @method   = method
-      @requests = []
-    end
-
-    def add_request(request)
-      @requests << request
-    end
-
-    def and_return(val)
-      @response = val
-    end
-
-    def matches?(request)
-      if url.kind_of?(String)
-        request.method == method && request.url == url
-      else
-        request.method == method && url =~ request.url
-      end
-    end
-  end
 end

data/lib/typhoeus/hydra/callbacks.rb

@@ -0,0 +1,24 @@
+module Typhoeus
+  class Hydra
+    module Callbacks
+      def self.extended(base)
+        class << base
+          attr_accessor :global_hooks
+        end
+        base.global_hooks = Hash.new { |h, k| h[k] = [] }
+      end
+
+      def after_request_before_on_complete(&block)
+        global_hooks[:after_request_before_on_complete] << block
+      end
+
+      def run_global_hooks_for(name, request)
+        global_hooks[name].each { |hook| hook.call(request) }
+      end
+
+      def clear_global_hooks
+        global_hooks.clear
+      end
+    end
+  end
+end

data/lib/typhoeus/hydra/connect_options.rb

@@ -0,0 +1,45 @@
+module Typhoeus
+  class Hydra
+    class NetConnectNotAllowedError < StandardError; end
+
+    module ConnectOptions
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      # This method checks to see if we should raise an error on
+      # a request.
+      #
+      # @raises NetConnectNotAllowedError
+      def check_allow_net_connect!(request)
+        if !Typhoeus::Hydra.allow_net_connect? and (!Typhoeus::Hydra.ignore_localhost? or !request.localhost?)
+          raise NetConnectNotAllowedError, "Real HTTP requests are not allowed. Unregistered request: #{request.inspect}"
+        end
+      end
+      private :check_allow_net_connect!
+
+      module ClassMethods
+        def self.extended(base)
+          class << base
+            attr_accessor :allow_net_connect
+            attr_accessor :ignore_localhost
+          end
+          base.allow_net_connect = true
+          base.ignore_localhost = false
+        end
+
+        # Returns whether we allow external HTTP connections.
+        # Useful for mocking/tests.
+        #
+        # @return [boolean] true/false
+        def allow_net_connect?
+          allow_net_connect
+        end
+
+        def ignore_localhost?
+          ignore_localhost
+        end
+      end
+    end
+  end
+end

data/lib/typhoeus/hydra/stubbing.rb

@@ -0,0 +1,52 @@
+module Typhoeus
+  class Hydra
+    module Stubbing
+      module SharedMethods
+        def stub(method, url, options = {})
+          stubs << HydraMock.new(url, method, options)
+          stubs.last
+        end
+
+        def clear_stubs
+          self.stubs = []
+        end
+
+        def find_stub_from_request(request)
+          stubs.detect { |stub| stub.matches?(request) }
+        end
+
+        def self.extended(base)
+          class << base
+            attr_accessor :stubs
+          end
+          base.stubs = []
+        end
+      end
+
+      def self.included(base)
+        base.extend(SharedMethods)
+        base.class_eval do
+          attr_accessor :stubs
+        end
+      end
+
+      def assign_to_stub(request)
+        m = find_stub_from_request(request)
+
+        # Fallback to global stubs.
+        m ||= self.class.find_stub_from_request(request)
+
+        if m
+          m.add_request(request)
+          @active_stubs << m
+          m
+        else
+          nil
+        end
+      end
+      private :assign_to_stub
+
+      include SharedMethods
+    end
+  end
+end

data/lib/typhoeus/hydra_mock.rb

@@ -0,0 +1,131 @@
+module Typhoeus
+  class HydraMock
+    attr_reader :url, :method, :requests, :uri
+
+    def initialize(url, method, options = {})
+      @url      = url
+      @uri      = URI.parse(url) if url.kind_of?(String)
+      @method   = method
+      @requests = []
+      @options = options
+      if @options[:headers]
+        @options[:headers] = Typhoeus::NormalizedHeaderHash.new(@options[:headers])
+      end
+
+      @current_response_index = 0
+    end
+
+    def body
+      @options[:body]
+    end
+
+    def body?
+      @options.has_key?(:body)
+    end
+
+    def headers
+      @options[:headers]
+    end
+
+    def headers?
+      @options.has_key?(:headers)
+    end
+
+    def add_request(request)
+      @requests << request
+    end
+
+    def and_return(val)
+      if val.respond_to?(:each)
+        @responses = val
+      else
+        @responses = [val]
+      end
+
+      # make sure to mark them as a mock.
+      @responses.each { |r| r.mock = true }
+
+      val
+    end
+
+    def response
+      if @current_response_index == (@responses.length - 1)
+        @responses.last
+      else
+        value = @responses[@current_response_index]
+        @current_response_index += 1
+        value
+      end
+    end
+
+    def matches?(request)
+      if !method_matches?(request) or !url_matches?(request)
+        return false
+      end
+
+      if body?
+        return false unless body_matches?(request)
+      end
+
+      if headers?
+        return false unless headers_match?(request)
+      end
+
+      true
+    end
+
+  private
+    def method_matches?(request)
+      self.method == :any or self.method == request.method
+    end
+
+    def url_matches?(request)
+      if url.kind_of?(String)
+        request_uri = URI.parse(request.url)
+        request_uri == self.uri
+      else
+        self.url =~ request.url
+      end
+    end
+
+    def body_matches?(request)
+      !request.body.nil? && !request.body.empty? && request.body == self.body
+    end
+
+    def headers_match?(request)
+      request_headers = NormalizedHeaderHash.new(request.headers)
+
+      if empty_headers?(self.headers)
+        empty_headers?(request_headers)
+      else
+        return false if empty_headers?(request_headers)
+
+        headers.each do |key, value|
+          return false unless header_value_matches?(value, request_headers[key])
+        end
+
+        true
+      end
+    end
+
+    def header_value_matches?(mock_value, request_value)
+      mock_arr = mock_value.is_a?(Array) ? mock_value : [mock_value]
+      request_arr = request_value.is_a?(Array) ? request_value : [request_value]
+
+      return false unless mock_arr.size == request_arr.size
+      mock_arr.all? do |value|
+        request_arr.any? { |a| value === a }
+      end
+    end
+
+    def empty_headers?(headers)
+      # We consider the default User-Agent header to be empty since
+      # Typhoeus always adds that.
+      headers.nil? || headers.empty? || default_typhoeus_headers?(headers)
+    end
+
+    def default_typhoeus_headers?(headers)
+      headers.size == 1 && headers['User-Agent'] == Typhoeus::USER_AGENT
+    end
+  end
+end