vcr 1.3.3 → 1.4.0

data/features/http_libraries/em_http_request.feature

@@ -0,0 +1,217 @@
+@exclude-jruby @exclude-rbx
+Feature: EM HTTP Request
+
+  EM HTTP Request allows multiple simultaneous asynchronous requests.
+  (The other HTTP libraries are synchronous).  The scenarios below
+  demonstrate how VCR can be used with asynchronous em-http requests.
+
+  Background:
+    Given a file named "vcr_setup.rb" with:
+      """
+      require 'em-http-request'
+      require 'vcr_cucumber_helpers'
+
+      start_sinatra_app(:port => 7777) do
+        %w[ foo bar bazz ].each_with_index do |path, index|
+          get "/#{path}" do
+            sleep index * 0.1 # ensure the async callbacks are invoked in order
+            ARGV[0] + ' ' + path
+          end
+        end
+      end
+
+      require 'vcr'
+
+      VCR.config do |c|
+        c.stub_with :webmock
+        c.cassette_library_dir = 'cassettes'
+      end
+      """
+
+  Scenario: multiple simultaneous HttpRequest objects
+    Given a file named "make_requests.rb" with:
+      """
+      require 'vcr_setup'
+
+      VCR.use_cassette('em_http', :record => :new_episodes) do
+        EventMachine.run do
+          http_array = %w[ foo bar bazz ].map do |p|
+            EventMachine::HttpRequest.new("http://localhost:7777/#{p}").get
+          end
+
+          http_array.each do |http|
+            http.callback do
+              puts http.response
+
+              if http_array.all? { |h| h.response.to_s != '' }
+                EventMachine.stop
+              end
+            end
+          end
+        end
+      end
+      """
+    When I run "ruby make_requests.rb Hello"
+    Then the output should contain:
+      """
+      Hello foo
+      Hello bar
+      Hello bazz
+      """
+    And the file "cassettes/em_http.yml" should contain YAML like:
+      """
+      --- 
+      - !ruby/struct:VCR::HTTPInteraction 
+        request: !ruby/struct:VCR::Request 
+          method: :get
+          uri: http://localhost:7777/foo
+          body: 
+          headers: 
+        response: !ruby/struct:VCR::Response 
+          status: !ruby/struct:VCR::ResponseStatus 
+            code: 200
+            message: OK
+          headers: 
+            content-type: 
+            - text/html;charset=utf-8
+            content-length: 
+            - "9"
+          body: Hello foo
+          http_version: "1.1"
+      - !ruby/struct:VCR::HTTPInteraction 
+        request: !ruby/struct:VCR::Request 
+          method: :get
+          uri: http://localhost:7777/bar
+          body: 
+          headers: 
+        response: !ruby/struct:VCR::Response 
+          status: !ruby/struct:VCR::ResponseStatus 
+            code: 200
+            message: OK
+          headers: 
+            content-type: 
+            - text/html;charset=utf-8
+            content-length: 
+            - "9"
+          body: Hello bar
+          http_version: "1.1"
+      - !ruby/struct:VCR::HTTPInteraction 
+        request: !ruby/struct:VCR::Request 
+          method: :get
+          uri: http://localhost:7777/bazz
+          body: 
+          headers: 
+        response: !ruby/struct:VCR::Response 
+          status: !ruby/struct:VCR::ResponseStatus 
+            code: 200
+            message: OK
+          headers: 
+            content-type: 
+            - text/html;charset=utf-8
+            content-length: 
+            - "10"
+          body: Hello bazz
+          http_version: "1.1"
+      """
+
+    When I run "ruby make_requests.rb Goodbye"
+    Then the output should contain:
+      """
+      Hello foo
+      Hello bar
+      Hello bazz
+      """
+
+  Scenario: MultiRequest
+    Given a file named "make_requests.rb" with:
+      """
+      require 'vcr_setup'
+
+      VCR.use_cassette('em_http', :record => :new_episodes) do
+        EventMachine.run do
+          multi = EventMachine::MultiRequest.new
+
+          %w[ foo bar bazz ].each do |path|
+            multi.add(EventMachine::HttpRequest.new("http://localhost:7777/#{path}").get)
+          end
+
+          multi.callback do
+            multi.responses[:succeeded].each do |http|
+              puts http.response
+            end
+            EventMachine.stop
+          end
+        end
+      end
+      """
+    When I run "ruby make_requests.rb Hello"
+    Then the output should contain:
+      """
+      Hello foo
+      Hello bar
+      Hello bazz
+      """
+    And the file "cassettes/em_http.yml" should contain YAML like:
+      """
+      --- 
+      - !ruby/struct:VCR::HTTPInteraction 
+        request: !ruby/struct:VCR::Request 
+          method: :get
+          uri: http://localhost:7777/foo
+          body: 
+          headers: 
+        response: !ruby/struct:VCR::Response 
+          status: !ruby/struct:VCR::ResponseStatus 
+            code: 200
+            message: OK
+          headers: 
+            content-type: 
+            - text/html;charset=utf-8
+            content-length: 
+            - "9"
+          body: Hello foo
+          http_version: "1.1"
+      - !ruby/struct:VCR::HTTPInteraction 
+        request: !ruby/struct:VCR::Request 
+          method: :get
+          uri: http://localhost:7777/bar
+          body: 
+          headers: 
+        response: !ruby/struct:VCR::Response 
+          status: !ruby/struct:VCR::ResponseStatus 
+            code: 200
+            message: OK
+          headers: 
+            content-type: 
+            - text/html;charset=utf-8
+            content-length: 
+            - "9"
+          body: Hello bar
+          http_version: "1.1"
+      - !ruby/struct:VCR::HTTPInteraction 
+        request: !ruby/struct:VCR::Request 
+          method: :get
+          uri: http://localhost:7777/bazz
+          body: 
+          headers: 
+        response: !ruby/struct:VCR::Response 
+          status: !ruby/struct:VCR::ResponseStatus 
+            code: 200
+            message: OK
+          headers: 
+            content-type: 
+            - text/html;charset=utf-8
+            content-length: 
+            - "10"
+          body: Hello bazz
+          http_version: "1.1"
+      """
+
+    When I run "ruby make_requests.rb Goodbye"
+    Then the output should contain:
+      """
+      Hello foo
+      Hello bar
+      Hello bazz
+      """
+

data/features/middleware/faraday.feature

@@ -0,0 +1,89 @@
+Feature: Faraday middleware
+
+  VCR provides middleware that can be used with Faraday.  You can use this as
+  an alternative to Faraday's built-in test adapter.
+
+  To use VCR with Faraday, you should configure VCR to stub with faraday and
+  use the provided middleware.  The middleware should come before the Faraday
+  HTTP adapter.  You should provide the middleware with a block where you set
+  the cassette name and options.  If your block accepts two arguments, the
+  env hash will be yielded, allowing you to dynamically set the cassette name
+  and options based on the request environment.
+
+  Background:
+    Given a file named "env_setup.rb" with:
+      """
+      require 'vcr_cucumber_helpers'
+
+      request_count = 0
+      start_sinatra_app(:port => 7777) do
+        get('/:path') { "Hello #{params[:path]} #{request_count += 1}" }
+      end
+
+      require 'vcr'
+
+      VCR.config do |c|
+        c.cassette_library_dir = 'cassettes'
+        c.stub_with :faraday
+      end
+      """
+
+  Scenario Outline: Use Faraday middleware
+    Given a file named "faraday_example.rb" with:
+      """
+      require 'env_setup'
+
+      conn = Faraday::Connection.new(:url => 'http://localhost:7777') do |builder|
+        builder.use VCR::Middleware::Faraday do |cassette|
+          cassette.name    'faraday_example'
+          cassette.options :record => :new_episodes
+        end
+
+        builder.adapter :<adapter>
+      end
+
+      puts "Response 1: #{conn.get('/foo').body}"
+      puts "Response 2: #{conn.get('/foo').body}"
+      """
+    When I run "ruby faraday_example.rb"
+    Then the output should contain:
+      """
+      Response 1: Hello foo 1
+      Response 2: Hello foo 1
+      """
+    And the file "cassettes/faraday_example.yml" should contain "body: Hello foo 1"
+
+    Examples:
+      | adapter  |
+      | net_http |
+      | typhoeus |
+
+  Scenario: Set cassette name based on faraday env
+    Given a file named "faraday_example.rb" with:
+      """
+      require 'env_setup'
+
+      conn = Faraday::Connection.new(:url => 'http://localhost:7777') do |builder|
+        builder.use VCR::Middleware::Faraday do |cassette, env|
+          cassette.name    env[:url].path.sub(/^\//, '')
+          cassette.options :record => :new_episodes
+        end
+
+        builder.adapter :net_http
+      end
+
+      puts "Response 1: #{conn.get('/foo').body}"
+      puts "Response 2: #{conn.get('/foo').body}"
+      puts "Response 3: #{conn.get('/bar').body}"
+      puts "Response 4: #{conn.get('/bar').body}"
+      """
+    When I run "ruby faraday_example.rb"
+    Then the output should contain:
+      """
+      Response 1: Hello foo 1
+      Response 2: Hello foo 1
+      Response 3: Hello bar 2
+      Response 4: Hello bar 2
+      """
+    And the file "cassettes/foo.yml" should contain "body: Hello foo 1"
+    And the file "cassettes/bar.yml" should contain "body: Hello bar 2"

data/features/middleware/rack.feature

@@ -0,0 +1,95 @@
+Feature: rack middleware
+
+  VCR provides a rack middleware that uses a cassette for the duration of
+  a request.  Simply provide VCR::Middleware::Rack with a block that sets
+  the cassette name and options.  You can set these based on the rack env
+  if your block accepts two arguments.
+
+  There useful in a couple different ways:
+
+  * In a rails app, you could use this to log all HTTP API calls made by
+    the rails app (using the :all record mode).  Of course, this will only
+    record HTTP API calls made in the request-response cycle--API calls that
+    are offloaded to a background job will not be logged.
+  * This can be used as middleware in a simple rack HTTP proxy, to record the
+    and replay the proxied requests.
+
+  Background:
+    Given a file named "remote_server.rb" with:
+      """
+      require 'vcr_cucumber_helpers'
+
+      request_count = 0
+      start_sinatra_app(:port => 7777) do
+        get('/:path') { "Hello #{params[:path]} #{request_count += 1}" }
+      end
+      """
+    And a file named "client.rb" with:
+      """
+      require 'remote_server'
+      require 'proxy_server'
+      require 'cgi'
+
+      url = URI.parse("http://localhost:8888?url=#{CGI.escape('http://localhost:7777/foo')}")
+
+      puts "Response 1: #{Net::HTTP.get_response(url).body}"
+      puts "Response 2: #{Net::HTTP.get_response(url).body}"
+      """
+    And the directory "cassettes" does not exist
+
+  Scenario: Use VCR rack middleware to record HTTP responses for a simple rack proxy app
+    Given a file named "proxy_server.rb" with:
+      """
+      require 'vcr'
+
+      start_sinatra_app(:port => 8888) do
+        use VCR::Middleware::Rack do |cassette|
+          cassette.name    'proxied'
+          cassette.options :record => :new_episodes
+        end
+
+        get('/') { Net::HTTP.get_response(URI.parse(params[:url])).body }
+      end
+
+      VCR.config do |c|
+        c.cassette_library_dir = 'cassettes'
+        c.stub_with :fakeweb
+        c.allow_http_connections_when_no_cassette = true
+      end
+      """
+    When I run "ruby client.rb"
+    Then the output should contain:
+      """
+      Response 1: Hello foo 1
+      Response 2: Hello foo 1
+      """
+    And the file "cassettes/proxied.yml" should contain "body: Hello foo 1"
+
+  Scenario: Set cassette name based on rack request env
+    Given a file named "proxy_server.rb" with:
+      """
+      require 'vcr'
+
+      start_sinatra_app(:port => 8888) do
+        use VCR::Middleware::Rack do |cassette, env|
+          cassette.name    env['SERVER_NAME']
+          cassette.options :record => :new_episodes
+        end
+
+        get('/') { Net::HTTP.get_response(URI.parse(params[:url])).body }
+      end
+
+      VCR.config do |c|
+        c.cassette_library_dir = 'cassettes'
+        c.stub_with :fakeweb
+        c.allow_http_connections_when_no_cassette = true
+      end
+      """
+    When I run "ruby client.rb"
+    Then the output should contain:
+      """
+      Response 1: Hello foo 1
+      Response 2: Hello foo 1
+      """
+    And the file "cassettes/localhost.yml" should contain "body: Hello foo 1"
+

data/features/step_definitions/cli_steps.rb

@@ -80,3 +80,10 @@ Then /^the file "([^"]*)" should contain each of these:$/ do |file_name, table|
   end
 end
 
+Then /^the cassette "([^"]*)" should have the following response bodies:$/ do |file, table|
+  interactions = in_current_dir { YAML.load_file(file) }
+  actual_response_bodies = interactions.map { |i| i.response.body }
+  expected_response_bodies = table.raw.flatten
+  actual_response_bodies.should =~ expected_response_bodies
+end
+

data/lib/vcr.rb

@@ -16,11 +16,25 @@ module VCR
 
   LOCALHOST_ALIASES = %w( localhost 127.0.0.1 0.0.0.0 )
 
+  class CassetteInUseError < StandardError; end
+  class TurnedOffError < StandardError; end
+
+  module Middleware
+    autoload :CassetteArguments, 'vcr/middleware/cassette_arguments'
+    autoload :Common,            'vcr/middleware/common'
+    autoload :Faraday,           'vcr/middleware/faraday'
+    autoload :Rack,              'vcr/middleware/rack'
+  end
+
   def current_cassette
     cassettes.last
   end
 
   def insert_cassette(*args)
+    unless turned_on?
+      raise TurnedOffError.new("VCR is turned off.  You must turn it on before you can insert a cassette.")
+    end
+
     cassette = Cassette.new(*args)
     cassettes.push(cassette)
     cassette
@@ -32,11 +46,12 @@ module VCR
     cassette
   end
 
-  def use_cassette(*args)
-    insert_cassette(*args)
+  def use_cassette(*args, &block)
+    cassette = insert_cassette(*args)
 
     begin
-      yield
+      # yield the cassette if the block accepts an argument or variable args
+      block.arity == 0 ? block.call : block.call(cassette)
     ensure
       eject_cassette
     end
@@ -45,7 +60,7 @@ module VCR
   def config
     yield VCR::Config
     http_stubbing_adapter.check_version!
-    http_stubbing_adapter.http_connections_allowed = false
+    http_stubbing_adapter.set_http_connections_allowed_to_default
     http_stubbing_adapter.ignore_localhost = VCR::Config.ignore_localhost?
   end
 
@@ -65,6 +80,7 @@ module VCR
           when :fakeweb;  HttpStubbingAdapters::FakeWeb
           when :webmock;  HttpStubbingAdapters::WebMock
           when :typhoeus; HttpStubbingAdapters::Typhoeus
+          when :faraday;  HttpStubbingAdapters::Faraday
           else raise ArgumentError.new("#{lib.inspect} is not a supported HTTP stubbing library.")
         end
       end
@@ -82,6 +98,34 @@ module VCR
     cassette.record_http_interaction(interaction)
   end
 
+  def turned_off
+    turn_off!
+
+    begin
+      yield
+    ensure
+      turn_on!
+    end
+  end
+
+  def turn_off!
+    if VCR.current_cassette
+      raise CassetteInUseError.new("A VCR cassette is currently in use.  You must eject it before you can turn VCR off.")
+    end
+
+    VCR.http_stubbing_adapter.http_connections_allowed = true
+    @turned_off = true
+  end
+
+  def turn_on!
+    VCR.http_stubbing_adapter.set_http_connections_allowed_to_default
+    @turned_off = false
+  end
+
+  def turned_on?
+    !@turned_off
+  end
+
   private
 
   def cassettes