pauldix-typhoeus 0.0.12 → 0.0.13

data/lib/typhoeus/remote.rb

@@ -4,8 +4,19 @@ module Typhoeus
   def self.included(base)
     base.extend ClassMethods
   end
+
+  class MockExpectedError < StandardError; end
     
   module ClassMethods
+    def allow_net_connect
+      @allow_net_connect = true if @allow_net_connect.nil?
+      @allow_net_connect
+    end
+
+    def allow_net_connect=(value)
+      @allow_net_connect = value
+    end
+    
     def mock(method, args = {})
       @remote_mocks ||= {}
       @remote_mocks[method] ||= {}
@@ -21,10 +32,18 @@ module Typhoeus
     def get_mock(method, url, options)
       return nil unless @remote_mocks
       if @remote_mocks.has_key? method
+        extra_response_args = { :requested_http_method => method,
+                                :requested_url => url }
         if @remote_mocks[method].has_key? url
-          get_mock_and_run_handlers(method, @remote_mocks[method][url], options)
+          get_mock_and_run_handlers(method,
+                                    @remote_mocks[method][url].merge(
+                                      extra_response_args),
+                                    options)
         elsif @remote_mocks[method].has_key? :catch_all
-          get_mock_and_run_handlers(method, @remote_mocks[method][:catch_all], options)
+          get_mock_and_run_handlers(method,
+                                    @remote_mocks[method][:catch_all].merge(
+                                      extra_response_args),
+                                    options)
         else
           nil
         end
@@ -32,9 +51,19 @@ module Typhoeus
         nil
       end
     end
+
+    def enforce_allow_net_connect!(http_verb, url)
+      if !allow_net_connect
+        raise MockExpectedError,
+              "Real HTTP connections are disabled. Unregistered request: " <<
+              "#{http_verb.to_s.upcase} #{url}\n" <<
+              "  Try: mock(:#{http_verb}, :url => \"#{url}\")"
+      end
+    end
     
     def get_mock_and_run_handlers(method, response_args, options)
-      response = Response.new(response_args[:code], response_args[:headers], response_args[:body], response_args[:time])
+      response = Response.new(response_args)
+     
       if response_args.has_key? :expected_body
         raise "#{method} expected body of \"#{response_args[:expected_body]}\" but received #{options[:body]}" if response_args[:expected_body] != options[:body]
       end
@@ -53,26 +82,42 @@ module Typhoeus
     
     def get(url, options = {})
       mock_object = get_mock(:get, url, options)
-      return mock_object if mock_object
-      remote_proxy_object(url, :get, options)
+      unless mock_object.nil?
+        mock_object
+      else
+        enforce_allow_net_connect!(:get, url)  
+        remote_proxy_object(url, :get, options)
+      end
     end
     
     def post(url, options = {}, &block)
       mock_object = get_mock(:post, url, options)
-      return mock_object if mock_object
-      remote_proxy_object(url, :post, options)
+      unless mock_object.nil?
+        mock_object
+      else
+        enforce_allow_net_connect!(:post, url)
+        remote_proxy_object(url, :post, options)
+      end
     end
 
     def put(url, options = {}, &block)
       mock_object = get_mock(:put, url, options)
-      return mock_object if mock_object
-      remote_proxy_object(url, :put, options)
+      unless mock_object.nil?
+        mock_object
+      else
+        enforce_allow_net_connect!(:put, url)
+        remote_proxy_object(url, :put, options)
+      end
     end
     
     def delete(url, options = {}, &block)
       mock_object = get_mock(:delete, url, options)
-      return mock_object if mock_object
-      remote_proxy_object(url, :delete, options)
+      unless mock_object.nil?
+        mock_object
+      else
+        enforce_allow_net_connect!(:delete, url)
+        remote_proxy_object(url, :delete, options)
+      end
     end
     
     def remote_proxy_object(url, method, options)
@@ -92,7 +137,15 @@ module Typhoeus
     end
     
     def remote_defaults(options)
-      @remote_defaults = options
+      @remote_defaults ||= {}
+      @remote_defaults.merge!(options)
+      @remote_defaults
+    end
+
+    # If we get subclassed, make sure that child inherits the remote defaults
+    # of the parent class.
+    def inherited(child)
+      child.__send__(:remote_defaults, @remote_defaults)
     end
     
     def call_remote_method(method_name, args)
@@ -176,4 +229,4 @@ module Typhoeus
       SRC
     end
   end # ClassMethods
-end
+end

data/lib/typhoeus/remote_proxy_object.rb

@@ -21,7 +21,12 @@ module Typhoeus
         
         unless @proxied_object
           Typhoeus.perform_easy_requests
-          response = Response.new(@easy.response_code, @easy.response_header, @easy.response_body, @easy.total_time_taken)
+          response = Response.new(:code => @easy.response_code,
+                                  :headers => @easy.response_header,
+                                  :body => @easy.response_body,
+                                  :time => @easy.total_time_taken,
+                                  :requested_url => @easy.url,
+                                  :requested_http_method => @easy.method)
           if @easy.response_code >= 200 && @easy.response_code < 300
             Typhoeus.release_easy_object(@easy)
             @proxied_object = @success.nil? ? response : @success.call(response)
@@ -39,4 +44,4 @@ module Typhoeus
       @proxied_object.__send__(sym, *args, &block)
     end
   end
-end
+end

data/lib/typhoeus/response.rb

@@ -1,12 +1,16 @@
 module Typhoeus
   class Response
-    attr_reader :code, :headers, :body, :time
+    attr_reader :code, :headers, :body, :time,
+                :requested_url, :requested_remote_method,
+                :requested_http_method
     
-    def initialize(response_code, response_headers, response_body, request_time)
-      @code    = response_code
-      @headers = response_headers
-      @body    = response_body
-      @time    = request_time
+    def initialize(params = {})
+      @code                     = params[:code]
+      @headers                  = params[:headers]
+      @body                     = params[:body]
+      @time                     = params[:time]
+      @requested_url            = params[:requested_url]
+      @requested_http_method    = params[:requested_http_method]
     end
   end
-end
+end

data/lib/typhoeus.rb

@@ -12,7 +12,7 @@ require 'typhoeus/remote_proxy_object'
 require 'typhoeus/response'
 
 module Typhoeus
-  VERSION = "0.0.12"
+  VERSION = "0.0.13"
   
   def self.easy_object_pool
     @easy_objects ||= []

data/spec/typhoeus/remote_proxy_object_spec.rb

@@ -34,6 +34,12 @@ describe Typhoeus::RemoteProxyObject do
     Typhoeus.should_receive(:perform_easy_requests).exactly(0).times
     response.code.should == 200
   end
+
+  it "should set the requested_url and requested_http_method on the response" do
+    response = Typhoeus::RemoteProxyObject.new(lambda {}, @easy)
+    response.requested_url.should == "http://localhost:3001"
+    response.requested_http_method.should == :get
+  end
   
   it "should call the on_success method with an easy object and proxy to the result of on_success" do
     klass = Class.new do
@@ -64,4 +70,4 @@ describe Typhoeus::RemoteProxyObject do
     k = Typhoeus::RemoteProxyObject.new(lambda {}, @easy, :on_failure => lambda {|e| klass.new(e)})
     k.blah.should == 0
   end
-end
+end

data/spec/typhoeus/remote_spec.rb

@@ -14,7 +14,48 @@ describe Typhoeus do
   after(:all) do
     stop_method_server(@pid)
   end
-  
+
+  describe "entirely disallowing HTTP connections in specs" do
+    describe "allow_net_connect" do
+      it "should default to true" do
+        @klass.allow_net_connect.should be_true
+      end
+
+      it "should be settable" do
+        @klass.allow_net_connect.should be_true
+        @klass.allow_net_connect = false
+        @klass.allow_net_connect.should be_false
+      end
+    end
+
+    describe "and hitting a URL that hasn't been mocked" do
+      it "should raise an error for any HTTP verbs" do
+        @klass.allow_net_connect = false
+
+        [:get, :put, :post, :delete].each do |method|
+          lambda {
+            @klass.send(method, "http://crazy_url_that_isnt_mocked.com")
+          }.should raise_error(Typhoeus::MockExpectedError)
+        end
+      end
+    end
+
+    describe "hitting a mocked URL that returns false" do
+      it "should not raise a MockExpectedError" do
+        @klass.allow_net_connect = false
+        @klass.mock(:delete,
+                    :url => "http://test.com",
+                    :code => 500,
+                    :body => 'ok')
+
+        lambda {
+          @klass.delete("http://test.com",
+                        :on_failure => lambda { |response| false })
+        }.should_not raise_error
+      end
+    end
+  end
+
   describe "mocking" do
     it "should mock out GET" do
       @klass.mock(:get)
@@ -117,6 +158,23 @@ describe Typhoeus do
         @klass.mock(:get, :url => "http://localhost:3001", :body => "hi", :code => 500)
         @klass.do_stuff.should == :fail
       end
+
+      it "should allow for subclassing a class that includes Typhoeus, and merging defaults" do
+        class TestA
+          include Typhoeus
+          remote_defaults :on_failure => lambda { |response|
+                                           :fail
+                                         }
+        end
+
+        class TestB < TestA
+          remote_defaults :base_uri => "http://localhost"
+          define_remote_method :do_stuff
+        end
+
+        TestB.mock(:get, :url => "http://localhost", :body => "hi", :code => 500)
+        TestB.do_stuff.should == :fail
+      end
     end
     
     describe "response hash" do
@@ -421,7 +479,14 @@ describe Typhoeus do
           define_remote_method :do_stuff, :base_uri => "http://localhost:3001", :params => {:foo => :bar}
         end
 
-        @klass.do_stuff(:params => {:asdf => :jkl}).body.should include("QUERY_STRING=foo=bar&asdf=jkl")
+        result = @klass.do_stuff(:params => {:asdf => :jkl})
+
+        # Make this test more robust to hash ordering.
+        query_string = result.body.match(/QUERY_STRING=([^\n]+)/)
+        params = query_string[1].split("&")
+        ["asdf=jkl", "foo=bar"].each do |param|
+          params.should include(param)
+        end
       end
     end
     
@@ -539,4 +604,4 @@ describe Typhoeus do
   #     end
   #   end
   # end
-end
+end

data/spec/typhoeus/response_spec.rb

@@ -3,19 +3,29 @@ require File.dirname(__FILE__) + '/../spec_helper'
 describe Typhoeus::Response do
   describe "initialize" do
     it "should store response_code" do
-      Typhoeus::Response.new(200, nil, nil, nil).code.should == 200
+      Typhoeus::Response.new(:code => 200).code.should == 200
     end
     
     it "should store response_headers" do
-      Typhoeus::Response.new(nil, "a header!", nil, nil).headers.should == "a header!"
+      Typhoeus::Response.new(:headers => "a header!").headers.should == "a header!"
     end
     
     it "should store response_body" do
-      Typhoeus::Response.new(nil, nil, "a body!", nil).body.should == "a body!"
+      Typhoeus::Response.new(:body => "a body!").body.should == "a body!"
     end
     
     it "should store request_time" do
-      Typhoeus::Response.new(nil, nil, nil, 1.23).time.should == 1.23
+      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
   end
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: pauldix-typhoeus
 version: !ruby/object:Gem::Version 
-  version: 0.0.12
+  version: 0.0.13
 platform: ruby
 authors: 
 - Paul Dix
@@ -51,6 +51,7 @@ files:
 - spec/servers/method_server.rb
 has_rdoc: true
 homepage: http://github.com/pauldix/typhoeus
+licenses: 
 post_install_message: 
 rdoc_options: []
 
@@ -72,7 +73,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.2.0
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 2
 summary: A library for interacting with web services (and building SOAs) at blinding speed.