vcr 0.1.1 → 0.1.2

data/features/replay_recorded_response.feature

@@ -42,7 +42,7 @@ Feature: Replay recorded response
       And we have a "temp/not_the_real_response" file with no previously recorded response for "http://example.com/foo"
      When I make HTTP get requests to "http://example.com" and "http://example.com/foo" within the "temp/not_the_real_response" none cassette
      Then the response for "http://example.com" should match /This is not the real response from example\.com/
-      And the HTTP get request to "http://example.com/foo" should result in a fakeweb error
+      And the HTTP get request to "http://example.com/foo" should result in a fakeweb error that mentions VCR
 
   @copy_not_the_real_response_to_temp
   Scenario: Make an HTTP request in a cassette with record mode set to :unregistered
@@ -50,4 +50,14 @@ Feature: Replay recorded response
     And we have a "temp/not_the_real_response" file with no previously recorded response for "http://example.com/foo"
    When I make HTTP get requests to "http://example.com" and "http://example.com/foo" within the "temp/not_the_real_response" unregistered cassette
    Then the response for "http://example.com" should match /This is not the real response from example\.com/
-    And the response for "http://example.com/foo" should match /The requested URL \/foo was not found/
+    And the response for "http://example.com/foo" should match /The requested URL \/foo was not found/
+
+  @replay_cassette3
+  Scenario: Replay multiple different recorded responses for requests to the same URL
+    Given this scenario is tagged with the vcr cassette tag: "@replay_cassette3"
+      And the "cucumber_tags/replay_cassette3" cache file has a response for "http://example.com" that matches /This is not the real response from example\.com/
+      And the "cucumber_tags/replay_cassette3" cache file has a response for "http://example.com" that matches /This is another fake response from example\.com/
+     When I make an HTTP get request to "http://example.com"
+      And I make an HTTP get request to "http://example.com"
+     Then response 1 for "http://example.com" should match /This is not the real response from example\.com/
+      And response 2 for "http://example.com" should match /This is another fake response from example\.com/

data/features/step_definitions/vcr_steps.rb

@@ -4,11 +4,16 @@ module VCRHelpers
   def have_expected_response(url, regex_str)
     simple_matcher("a response from #{url} that matches /#{regex_str}/") do |responses|
       regex = /#{regex_str}/i
-      response = responses.detect { |r| URI.parse(r.uri) == URI.parse(url) }
-      response.should_not be_nil
-      response.response.body.should =~ regex
+      responses = responses.select { |r| URI.parse(r.uri) == URI.parse(url) }
+      responses.detect { |r| r.response.body =~ regex }
     end
   end
+
+  def recorded_responses_for(cassette_name)
+    yaml_file = File.join(VCR::Config.cache_dir, "#{cassette_name}.yml")
+    yaml = File.open(yaml_file, 'r') { |f| f.read }
+    responses = YAML.load(yaml)
+  end
 end
 World(VCRHelpers)
 
@@ -42,51 +47,62 @@ Given /^the previous scenario was tagged with the vcr cassette tag: "([^\"]*)"$/
   VCR::CucumberTags.tags.should include(tag)
 end
 
-When /^I make an( asynchronous)? HTTP get request to "([^\"]*)"$/ do |asynchronous, url|
-  @http_requests ||= {}
+When /^I make an(.*)? HTTP (?:get|post) request to "([^\"]*)"$/ do |request_type, url|
+  @http_requests ||= Hash.new([])
+  uri = URI.parse(url)
+  path = uri.path.to_s == '' ? '/' : uri.path
   begin
-    if asynchronous =~ /asynchronous/
-      uri = URI.parse(url)
-      path = uri.path.to_s == '' ? '/' : uri.path
-      result = Net::HTTP.new(uri.host, uri.port).request_get(path) { |r| r.read_body { } }
-      result.body.should be_a(Net::ReadAdapter)
-    else
-      result = Net::HTTP.get_response(URI.parse(url))
+    case request_type
+      when /asynchronous/
+        result = Net::HTTP.new(uri.host, uri.port).request_get(path) { |r| r.read_body { } }
+        result.body.should be_a(Net::ReadAdapter)
+      when /recursive/
+        result = Net::HTTP.new(uri.host, uri.port).post(path, nil)
+      else
+        result = Net::HTTP.get_response(uri)
     end
   rescue => e
     result = e
   end
-  @http_requests[url] = result
+  @http_requests[url] += [result]
 end
 
-When /^I make(?: an)?( asynchronous)? HTTP get requests? to "([^\"]*)"(?: and "([^\"]*)")? within the "([^\"]*)" ?(#{VCR::Cassette::VALID_RECORD_MODES.join('|')})? cassette$/ do |asynchronous, url1, url2, cassette_name, record_mode|
+When /^I make(?: an)?(.*)? HTTP (get|post) requests? to "([^\"]*)"(?: and "([^\"]*)")? within the "([^\"]*)" ?(#{VCR::Cassette::VALID_RECORD_MODES.join('|')})? cassette$/ do |request_type, method, url1, url2, cassette_name, record_mode|
   record_mode ||= :unregistered
   record_mode = record_mode.to_sym
   urls = [url1, url2].select { |u| u.to_s.size > 0 }
   VCR.with_cassette(cassette_name, :record => record_mode) do
     urls.each do |url|
-      When %{I make an#{asynchronous} HTTP get request to "#{url}"}
+      When %{I make an#{request_type} HTTP #{method} request to "#{url}"}
     end
   end
 end
 
 Then /^the "([^\"]*)" cache file should have a response for "([^\"]*)" that matches \/(.+)\/$/ do |cassette_name, url, regex_str|
-  yaml_file = File.join(VCR::Config.cache_dir, "#{cassette_name}.yml")
-  responses = File.open(yaml_file, 'r') { |f| YAML.load(f.read) }
+  responses = recorded_responses_for(cassette_name)
   responses.should have_expected_response(url, regex_str)
 end
 
+Then /^the "([^\"]*)" cache file should have exactly (\d+) response$/ do |cassette_name, response_count|
+  responses = recorded_responses_for(cassette_name)
+  responses.should have(response_count.to_i).responses
+end
+
 Then /^I can test the scenario cassette's recorded responses in the next scenario, after the cassette has been destroyed$/ do
   # do nothing...
 end
 
-Then /^the HTTP get request to "([^\"]*)" should result in a fakeweb error$/ do |url|
-  @http_requests[url].should be_instance_of(FakeWeb::NetConnectNotAllowedError)
+Then /^the HTTP get request to "([^\"]*)" should result in a fakeweb error that mentions VCR$/ do |url|
+  result = @http_requests[url][0]
+  result.should be_instance_of(FakeWeb::NetConnectNotAllowedError)
+  result.message.should =~ /VCR/
 end
 
-Then /^the response for "([^\"]*)" should match \/(.+)\/$/ do |url, regex_str|
+Then /^(?:the )?response(?: (\d+))? for "([^\"]*)" should match \/(.+)\/$/ do |response_num, url, regex_str|
+  response_num = response_num.to_i || 0
+  response_num -= 1 if response_num > 0 # translate to 0-based array index.
   regex = /#{regex_str}/i
-  @http_requests[url].body.should =~ regex
+  @http_requests[url][response_num].body.should =~ regex
 end
 
 Then /^there should not be a "([^\"]*)" cache file$/ do |cassette_name|

data/features/support/env.rb

@@ -51,5 +51,5 @@ end
 
 VCR.cucumber_tags do |t|
   t.tags '@record_cassette1', '@record_cassette2', :record => :unregistered
-  t.tags '@replay_cassette1', '@replay_cassette2', :record => :none
+  t.tags '@replay_cassette1', '@replay_cassette2', '@replay_cassette3', :record => :none
 end

data/lib/vcr.rb

@@ -1,11 +1,12 @@
 require 'vcr/cassette'
 require 'vcr/config'
 require 'vcr/cucumber_tags'
-require 'vcr/fake_web_extensions'
-require 'vcr/net_http_extensions'
-require 'vcr/net_read_adapter_extensions'
 require 'vcr/recorded_response'
 
+require 'vcr/extensions/fake_web'
+require 'vcr/extensions/net_http'
+require 'vcr/extensions/net_read_adapter'
+
 module VCR
   extend self
 

data/lib/vcr/cassette.rb

@@ -67,8 +67,16 @@ module VCR
         recorded_responses.replace(@original_recorded_responses)
       end
 
+      register_responses_with_fakeweb
+    end
+
+    def register_responses_with_fakeweb
+      requests = Hash.new([])
       recorded_responses.each do |rr|
-        FakeWeb.register_uri(rr.method, rr.uri, { :response => rr.response })
+        requests[[rr.method, rr.uri]] += [rr.response]
+      end
+      requests.each do |request, responses|
+        FakeWeb.register_uri(request.first, request.last, responses.map{ |r| { :response => r } })
       end
     end
 

data/lib/vcr/{fake_web_extensions.rb → extensions/fake_web.rb}

@@ -15,4 +15,10 @@ module FakeWeb
       end
     end
   end
+
+  class NetConnectNotAllowedError
+    def message
+      super + '.  You can use VCR to automatically record this request and replay it later with fakeweb.  For more details, see the VCR README at: http://github.com/myronmarston/vcr'
+    end
+  end
 end

data/lib/vcr/{net_http_extensions.rb → extensions/net_http.rb}

@@ -3,9 +3,12 @@ require 'net/http'
 module Net
   class HTTP
     def request_with_vcr(request, body = nil, &block)
+      @__request_with_vcr_call_count = (@__request_with_vcr_call_count || 0) + 1
       response = request_without_vcr(request, body, &block)
-      __store_response_with_vcr__(response, request)
+      __store_response_with_vcr__(response, request) if @__request_with_vcr_call_count == 1
       response
+    ensure
+      @__request_with_vcr_call_count -= 1
     end
     alias_method :request_without_vcr, :request
     alias_method :request, :request_with_vcr

data/spec/cassette_spec.rb

@@ -76,9 +76,9 @@ describe VCR::Cassette do
         cassette = VCR::Cassette.new('example', :record => record_mode)
 
         if load_responses
-          cassette.should have(2).recorded_responses
+          cassette.should have(3).recorded_responses
 
-          rr1, rr2 = cassette.recorded_responses.first, cassette.recorded_responses.last
+          rr1, rr2, rr3 = *cassette.recorded_responses
 
           rr1.method.should == :get
           rr1.uri.should == 'http://example.com:80/'
@@ -87,6 +87,10 @@ describe VCR::Cassette do
           rr2.method.should == :get
           rr2.uri.should == 'http://example.com:80/foo'
           rr2.response.body.should =~ /foo was not found on this server/
+
+          rr3.method.should == :get
+          rr3.uri.should == 'http://example.com:80/'
+          rr3.response.body.should =~ /Another example\.com response/
         else
           cassette.should have(0).recorded_responses
         end
@@ -98,15 +102,15 @@ describe VCR::Cassette do
 
         rr1 = FakeWeb.response_for(:get, "http://example.com")
         rr2 = FakeWeb.response_for(:get, "http://example.com/foo")
+        rr3 = FakeWeb.response_for(:get, "http://example.com")
 
         if load_responses
-          rr1.should_not be_nil
-          rr2.should_not be_nil
+          [rr1, rr2, rr3].compact.should have(3).responses
           rr1.body.should =~ /You have reached this web page by typing.+example\.com/
           rr2.body.should =~ /foo was not found on this server/
+          rr3.body.should =~ /Another example\.com response/
         else
-          rr1.should be_nil
-          rr2.should be_nil
+          [rr1, rr2, rr3].compact.should have(0).responses
         end
       end
     end
@@ -153,12 +157,12 @@ describe VCR::Cassette do
       cache_file = File.expand_path(File.dirname(__FILE__) + "/fixtures/#{RUBY_VERSION}/cassette_spec/example.yml")
       FileUtils.cp cache_file, File.join(@temp_dir, 'previously_recorded_responses.yml')
       cassette = VCR::Cassette.new('previously_recorded_responses')
-      cassette.should have(2).recorded_responses
+      cassette.should have(3).recorded_responses
       new_recorded_response = VCR::RecordedResponse.new(:get, 'http://example.com/bar', :example_dot_com_bar_response)
       cassette.store_recorded_response!(new_recorded_response)
       cassette.destroy!
       saved_recorded_responses = File.open(cassette.cache_file, "r") { |f| YAML.load(f.read) }
-      saved_recorded_responses.should have(3).recorded_responses
+      saved_recorded_responses.should have(4).recorded_responses
       saved_recorded_responses.last.should == new_recorded_response
     end
   end

data/spec/{fake_web_extensions_spec.rb → extensions/fake_web_spec.rb}

@@ -1,6 +1,6 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
-describe "FakeWebExtensions" do
+describe "FakeWeb Extensions" do
   describe "#remove_from_registry with (:get, 'http://example.com')" do
     before(:each) do
       FakeWeb.register_uri(:get, 'http://example.com', :body => "Example dot com!")
@@ -23,4 +23,11 @@ describe "FakeWebExtensions" do
       @remove_example_dot_com.should_not change { FakeWeb.registered_uri?(:get, 'http://google.com') }
     end
   end
+
+  describe 'FakeWeb::NetConnectNotAllowedError#message' do
+    it 'includes a note about VCR' do
+      FakeWeb::NetConnectNotAllowedError.new('The fakeweb error message').message.should ==
+      'The fakeweb error message.  You can use VCR to automatically record this request and replay it later with fakeweb.  For more details, see the VCR README at: http://github.com/myronmarston/vcr'
+    end
+  end
 end

data/spec/{net_http_extensions_spec.rb → extensions/net_http_spec.rb}

@@ -1,6 +1,6 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
-describe "NetHttpExtensions" do
+describe "Net::HTTP Extensions" do
   before(:all) do
     @orig_allow_net_connect = FakeWeb.allow_net_connect?
     FakeWeb.allow_net_connect = true
@@ -24,6 +24,11 @@ describe "NetHttpExtensions" do
       Net::HTTP.get(URI.parse('http://example.com'))
     end
 
+    it 'calls #store_recorded_response! only once, even when Net::HTTP internally recursively calls #request' do
+      @current_cassette.should_receive(:store_recorded_response!).once
+      Net::HTTP.new('example.com', 80).post('/', nil)
+    end
+
     it 'does not have an error if there is no current cassette' do
       VCR.stub!(:current_cassette).and_return(nil)
       lambda { Net::HTTP.get(URI.parse('http://example.com')) }.should_not raise_error

data/spec/{net_read_adapter_extensions_spec.rb → extensions/net_read_adapter_spec.rb}

@@ -1,4 +1,4 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 describe 'Net::ReadAdapter extensions' do
   it 'delegates yaml serialization to the body string' do

data/spec/fixtures/1.8.6/cassette_spec/example.yml

@@ -1,9 +1,9 @@
---- 
-- !ruby/struct:VCR::RecordedResponse 
-  method: :get
-  uri: http://example.com:80/
-  response: !ruby/object:Net::HTTPOK 
-    body: |
+--- 
+- !ruby/struct:VCR::RecordedResponse 
+  method: :get
+  uri: http://example.com:80/
+  response: !ruby/object:Net::HTTPOK 
+    body: |
       <HTML>
       <HEAD>
         <TITLE>Example Web Page</TITLE>
@@ -18,61 +18,91 @@
       </BODY>
       </HTML>
       
-
-    body_exist: true
-    code: "200"
-    header: 
-      last-modified: 
-      - Tue, 15 Nov 2005 13:24:10 GMT
-      connection: 
-      - Keep-Alive
-      date: 
-      - Thu, 25 Feb 2010 07:52:38 GMT
-      content-type: 
-      - text/html; charset=UTF-8
-      etag: 
-      - "\"24ec5-1b6-4059a80bfd280\""
-      server: 
-      - Apache/2.2.3 (CentOS)
-      content-length: 
-      - "438"
-      age: 
-      - "3009"
-      accept-ranges: 
-      - bytes
-    http_version: "1.1"
-    message: OK
-    read: true
-    socket: 
-- !ruby/struct:VCR::RecordedResponse 
-  method: :get
-  uri: http://example.com:80/foo
-  response: !ruby/object:Net::HTTPNotFound 
-    body: |
-      <!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
-      <html><head>
-      <title>404 Not Found</title>
-      </head><body>
-      <h1>Not Found</h1>
-      <p>The requested URL /foo was not found on this server.</p>
-      <hr>
-      <address>Apache/2.2.3 (CentOS) Server at example.com Port 80</address>
-      </body></html>
-
-    body_exist: true
-    code: "404"
-    header: 
-      connection: 
-      - close
-      content-type: 
-      - text/html; charset=iso-8859-1
-      date: 
-      - Thu, 25 Feb 2010 07:52:38 GMT
-      server: 
-      - Apache/2.2.3 (CentOS)
-      content-length: 
-      - "277"
-    http_version: "1.1"
-    message: Not Found
-    read: true
-    socket: 
+
+    body_exist: true
+    code: "200"
+    header: 
+      last-modified: 
+      - Tue, 15 Nov 2005 13:24:10 GMT
+      connection: 
+      - Keep-Alive
+      date: 
+      - Thu, 25 Feb 2010 07:52:38 GMT
+      content-type: 
+      - text/html; charset=UTF-8
+      etag: 
+      - "\"24ec5-1b6-4059a80bfd280\""
+      server: 
+      - Apache/2.2.3 (CentOS)
+      content-length: 
+      - "438"
+      age: 
+      - "3009"
+      accept-ranges: 
+      - bytes
+    http_version: "1.1"
+    message: OK
+    read: true
+    socket: 
+- !ruby/struct:VCR::RecordedResponse 
+  method: :get
+  uri: http://example.com:80/foo
+  response: !ruby/object:Net::HTTPNotFound 
+    body: |
+      <!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
+      <html><head>
+      <title>404 Not Found</title>
+      </head><body>
+      <h1>Not Found</h1>
+      <p>The requested URL /foo was not found on this server.</p>
+      <hr>
+      <address>Apache/2.2.3 (CentOS) Server at example.com Port 80</address>
+      </body></html>
+
+    body_exist: true
+    code: "404"
+    header: 
+      connection: 
+      - close
+      content-type: 
+      - text/html; charset=iso-8859-1
+      date: 
+      - Thu, 25 Feb 2010 07:52:38 GMT
+      server: 
+      - Apache/2.2.3 (CentOS)
+      content-length: 
+      - "277"
+    http_version: "1.1"
+    message: Not Found
+    read: true
+    socket: 
+- !ruby/struct:VCR::RecordedResponse 
+  method: :get
+  uri: http://example.com:80/
+  response: !ruby/object:Net::HTTPOK 
+    body: Another example.com response
+    body_exist: true
+    code: "200"
+    header: 
+      last-modified: 
+      - Tue, 15 Nov 2005 13:24:10 GMT
+      connection: 
+      - Keep-Alive
+      date: 
+      - Thu, 25 Feb 2010 07:52:38 GMT
+      content-type: 
+      - text/html; charset=UTF-8
+      etag: 
+      - "\"24ec5-1b6-4059a80bfd280\""
+      server: 
+      - Apache/2.2.3 (CentOS)
+      content-length: 
+      - "438"
+      age: 
+      - "3009"
+      accept-ranges: 
+      - bytes
+    http_version: "1.1"
+    message: OK
+    read: true
+    socket: