artifice-passthru 0.1.0

data/README.md

@@ -0,0 +1,43 @@
+Artifice::Passthru
+==================
+
+[Artifice][] is a great way to mock HTTP requests in your Ruby applications, 
+sending all Net::HTTP requests to a Rack application.
+
+That's great until you find that, for one reason or another, you *actually* need 
+to make **real** HTTP requests!
+
+There are a few reasons why you might need to do this:
+
+ - You want to test that real HTTP requests work
+ - Your test suite uses HTTP to communicate with its testing tools (eg. Capybara/Selenium requires HTTP) 
+ - Your test suite calls lots of real APIs and you want to iteratively refactor it to use Artifice
+ - ?
+
+Usage
+-----
+
+```ruby
+require 'artifice/passthru'
+
+# If you want to give a class or module (and all of its subclasses)
+# access to the real Net::HTTP, you can #use_real_net_http
+Artifice.use_real_net_http MyModule
+
+Artifice.activate_with lambda { |env|
+  if env['SERVER_NAME'] == 'api.twitter.com'
+    # Inside of your Artifice Rack application, you can call Artifice.passthru! which:
+    # - looks at the current Artifice request
+    # - makes a real HTTP request
+    # - returns a Rack response representing the actual HTTP response that was returned
+    Artifice.passthru!   # <--- will make the real HTTP call and return the response
+  else
+    # return faked responses using your Rack application as you normally would
+    [ 200, {}, ['Hi!'] ]
+  end
+}
+```
+
+That's all!
+
+[artifice]: https://github.com/wycats/artifice

data/lib/artifice/passthru.rb

@@ -0,0 +1,2 @@
+# Helper file allowing you to: require 'artifice/passthru'
+require File.dirname(__FILE__) + '/../artifice-passthru'

data/lib/artifice-passthru.rb

@@ -0,0 +1,98 @@
+require 'artifice' unless defined? Artifice
+
+module Artifice # :nodoc:
+
+  # Artifice.passthru! returns a Rack response created by making a *real* Net::HTTP 
+  # request (using the Artifice::Passthru.last_request_info) and then turning 
+  # the resulting Net::HTTPResponse object into a Rack response (which Artifice expects).
+  def self.passthru!
+    Artifice::Passthru.make_real_request_and_return_response!
+  end
+
+  # Given a constant (class or module), this gives it access to the *real* Net::HTTP so 
+  # every request made from within this class/module will use the real Net::HTTP
+  def self.use_real_net_http class_or_module
+    Artifice::Passthru.setup_to_use_real_net_http class_or_module
+  end
+
+  # Artifice Passthru
+  module Passthru
+
+    # Simple class for storing information about the last #request that was made, 
+    # allowing us to recreate the request
+    class RequestInfo
+      attr_accessor :address, :port, :request, :body, :block
+
+      def initialize address, port, req, body, block
+        self.address = address
+        self.port    = port
+        self.request = req
+        self.body    = body
+        self.block   = block
+      end
+    end
+
+    # When Artifice::Passthru is included into Artifice::Net::HTTP, it uses "alias_method_chain" 
+    # to override the #request method so we can get the arguments that were passed.
+    def self.included base
+      base.class_eval do
+        alias_method :request_without_passthru_argument_tracking, :request
+        alias_method :request, :request_with_passthru_argument_tracking
+      end
+    end
+
+    # Returns the last information that were passed to Net::HTTP#request (which Artifice hijacked) 
+    # so we can use these arguments to fire off a real request, if necessary.
+    def self.last_request_info
+      Thread.current[:artifice_passthru_arguments]
+    end
+
+    # Accepts and stores the last information that were passed to Net::HTTP#request (which Artifice hijacked) 
+    # so we can use these arguments to fire off a real request, if necessary.
+    def self.last_request_info= request_info
+      Thread.current[:artifice_passthru_arguments] = request_info
+    end
+
+    # Makes a real Net::HTTP request and returns the response, converted to a Rack response
+    def self.make_real_request_and_return_response!
+      raise 'Artifice.passthru! was called but no previous Artifice request was found to make via real Net::HTTP' if last_request_info.nil?
+      to_rack_response make_real_request(last_request_info)
+    end
+
+    # Given a Net::HTTPResponse, returns a Rack response
+    def self.to_rack_response net_http_response
+      # There's some voodoo magic going on that makes the real Net::HTTP#request method populate our response body for us?
+      headers = net_http_response.instance_variable_get('@header').inject({}){|all,this| all[this.first] = this.last.join("\n"); all }
+      [ net_http_response.code, headers, [net_http_response.body] ]
+    end
+
+    # Given the last_request_info (that would normally be passed to Net::HTTP#request), 
+    # makes a real request and returns the Net::HTTPResponse
+    def self.make_real_request request_info
+      http = Artifice::NET_HTTP.new request_info.address, request_info.port
+      http.request request_info.request, request_info.body, &request_info.block
+    end
+
+    # Given a constant (class or module), this gives it access to the *real* Net::HTTP so 
+    # every request made from within this class/module will use the real Net::HTTP
+    #
+    # Taken from: http://matschaffer.com/2011/04/net-http-mock-cucumber/
+    def self.setup_to_use_real_net_http class_or_module
+      class_or_module.class_eval %{
+        Net = ::Net.dup
+        module Net
+          HTTP = Artifice::NET_HTTP
+        end
+      }
+    end
+
+    # Simply stores the arguments that are passed and then calls "super" (request_without_passthru_argument_tracking)
+    def request_with_passthru_argument_tracking req, body = nil, &block
+      Artifice::Passthru.last_request_info = RequestInfo.new address, port, req, body, block
+      request_without_passthru_argument_tracking req, body, &block
+    end
+  end
+end
+
+# Inject our #request method override into Artifice's implementation of Net::HTTP
+Artifice::Net::HTTP.send :include, Artifice::Passthru

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: artifice-passthru
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- remi
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-28 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: artifice
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: Artifice extension that allows you to let certain requests pass thru to use HTTP
+email: remi@remitaylor.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.md
+- lib/artifice/passthru.rb
+- lib/artifice-passthru.rb
+has_rdoc: true
+homepage: https://github.com/remi/artifice-passthru
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Easily use real Net::HTTP with Artifice
+test_files: []
+