vcr 0.3.1 → 0.4.0

data/lib/vcr/structs.rb

@@ -0,0 +1,44 @@
+require 'forwardable'
+
+module VCR
+  class Request < Struct.new(:method, :uri, :body, :headers)
+    def self.from_net_http_request(net_http, request)
+      new(
+        request.method.downcase.to_sym,
+        VCR.http_stubbing_adapter.request_uri(net_http, request),
+        request.body,
+        request.to_hash
+      )
+    end
+  end
+
+  class ResponseStatus < Struct.new(:code, :message)
+    def self.from_net_http_response(response)
+      new(response.code.to_i, response.message)
+    end
+  end
+
+  class Response < Struct.new(:status, :headers, :body, :http_version)
+    def self.from_net_http_response(response)
+      new(
+        ResponseStatus.from_net_http_response(response),
+        response.to_hash,
+        response.body,
+        response.http_version
+      )
+    end
+  end
+
+  class HTTPInteraction < Struct.new(:request, :response)
+    extend ::Forwardable
+
+    def_delegators :request, :uri, :method
+
+    def self.from_net_http_objects(net_http, request, response)
+      new(
+        Request.from_net_http_request(net_http, request),
+        Response.from_net_http_response(response)
+      )
+    end
+  end
+end

data/lib/vcr/task_runner.rb

@@ -0,0 +1,47 @@
+require 'vcr'
+
+module VCR
+  module TaskRunner
+    extend self
+
+    def migrate_cassettes(dir)
+      with_recorded_response_defined do
+        FileUtils.cp_r(dir, "#{dir}-backup")
+
+        Dir.glob(dir + '/**/*.yml').each do |cassette_file|
+          recorded_responses = YAML.load(File.read(cassette_file))
+          next unless recorded_responses.is_a?(Enumerable) && recorded_responses.all? { |rr| rr.is_a?(VCR::RecordedResponse) }
+
+          interactions = recorded_responses.map do |recorded_response|
+            http_interaction(recorded_response)
+          end
+
+          File.open(cassette_file, 'w') { |f| f.write(interactions.to_yaml) }
+        end
+      end
+    end
+
+    private
+
+    def http_interaction(recorded_response)
+      VCR::HTTPInteraction.new(
+        request(recorded_response),
+        VCR::Response.from_net_http_response(recorded_response.response)
+      )
+    end
+
+    def request(recorded_response)
+      VCR::Request.new(recorded_response.method, recorded_response.uri)
+    end
+
+    def with_recorded_response_defined
+      VCR.const_set(:RecordedResponse, Class.new(Struct.new(:method, :uri, :response, :request_body, :request_headers)))
+
+      begin
+        yield
+      ensure
+        VCR.send(:remove_const, :RecordedResponse)
+      end
+    end
+  end
+end

data/lib/vcr/tasks/vcr.rake

@@ -0,0 +1,9 @@
+require 'vcr/task_runner'
+
+namespace :vcr do
+  desc 'Migrates your VCR cassettes in DIR from the 0.3.1 format to the 0.4+ format'
+  task :migrate_cassettes do
+    raise "You must pass the cassette library directory as DIR" if ENV['DIR'].to_s == ''
+    VCR::TaskRunner.migrate_cassettes(ENV['DIR'])
+  end
+end

data/spec/cassette_spec.rb

@@ -26,21 +26,30 @@ describe VCR::Cassette do
     end
   end
 
-  describe '#store_recorded_response!' do
-    it 'adds the recorded response to #recorded_responses' do
-      recorded_response = VCR::RecordedResponse.new(:get, 'http://example.com', :response)
+  describe '#record_http_interaction' do
+    it 'adds the interaction to #recorded_interactions' do
       cassette = VCR::Cassette.new(:test_cassette)
-      cassette.recorded_responses.should == []
-      cassette.store_recorded_response!(recorded_response)
-      cassette.recorded_responses.should == [recorded_response]
+      cassette.recorded_interactions.should == []
+      cassette.record_http_interaction(:the_interaction)
+      cassette.recorded_interactions.should == [:the_interaction]
     end
   end
 
   describe 'on creation' do
+    it 'raises an error with a helpful message when loading an old unsupported cassette' do
+      VCR::Config.cassette_library_dir = File.expand_path(File.dirname(__FILE__) + "/fixtures/#{RUBY_VERSION}")
+      lambda { VCR::Cassette.new('0_3_1_cassette') }.should raise_error(/The VCR cassette 0_3_1_cassette uses an old format that is now deprecated/)
+    end
+
     it "raises an error if given an invalid record mode" do
       lambda { VCR::Cassette.new(:test, :record => :not_a_record_mode) }.should raise_error(ArgumentError)
     end
 
+    it 'creates a stubs checkpoint on the http_stubbing_adapter' do
+      VCR.http_stubbing_adapter.should_receive(:create_stubs_checkpoint).with('example').once
+      VCR::Cassette.new('example')
+    end
+
     VCR::Cassette::VALID_RECORD_MODES.each do |mode|
       it "defaults the record mode to #{mode} when VCR::Config.default_cassette_options[:record] is #{mode}" do
         VCR::Config.default_cassette_options = { :record => mode }
@@ -49,56 +58,49 @@ describe VCR::Cassette do
       end
     end
 
-    { :new_episodes => true, :all => true, :none => false }.each do |record_mode, allow_fakeweb_connect|
-      it "sets FakeWeb.allow_net_connect to #{allow_fakeweb_connect} when the record mode is #{record_mode}" do
-        FakeWeb.allow_net_connect = !allow_fakeweb_connect
+    { :new_episodes => true, :all => true, :none => false }.each do |record_mode, http_connections_allowed|
+      it "sets http_connections_allowed to #{http_connections_allowed} on the http stubbing adapter when the record mode is #{record_mode}" do
+        VCR.http_stubbing_adapter.should_receive(:http_connections_allowed=).with(http_connections_allowed)
         VCR::Cassette.new(:name, :record => record_mode)
-        FakeWeb.allow_net_connect?.should == allow_fakeweb_connect
       end
     end
 
-    { :new_episodes => true, :all => false, :none => true }.each do |record_mode, load_responses|
-      it "#{load_responses ? 'loads' : 'does not load'} the recorded responses from the library yml file when the record mode is #{record_mode}" do
+    { :new_episodes => true, :all => false, :none => true }.each do |record_mode, load_interactions|
+      it "#{load_interactions ? 'loads' : 'does not load'} the recorded interactions from the library yml file when the record mode is #{record_mode}" do
         VCR::Config.cassette_library_dir = File.expand_path(File.dirname(__FILE__) + "/fixtures/#{RUBY_VERSION}/cassette_spec")
         cassette = VCR::Cassette.new('example', :record => record_mode)
 
-        if load_responses
-          cassette.should have(3).recorded_responses
+        if load_interactions
+          cassette.should have(3).recorded_interactions
 
-          rr1, rr2, rr3 = *cassette.recorded_responses
+          i1, i2, i3 = *cassette.recorded_interactions
 
-          rr1.method.should == :get
-          rr1.uri.should == 'http://example.com:80/'
-          rr1.response.body.should =~ /You have reached this web page by typing.+example\.com/
+          i1.request.method.should == :get
+          i1.request.uri.should == 'http://example.com:80/'
+          i1.response.body.should =~ /You have reached this web page by typing.+example\.com/
 
-          rr2.method.should == :get
-          rr2.uri.should == 'http://example.com:80/foo'
-          rr2.response.body.should =~ /foo was not found on this server/
+          i2.request.method.should == :get
+          i2.request.uri.should == 'http://example.com:80/foo'
+          i2.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/
+          i3.request.method.should == :get
+          i3.request.uri.should == 'http://example.com:80/'
+          i3.response.body.should =~ /Another example\.com response/
         else
-          cassette.should have(0).recorded_responses
+          cassette.should have(0).recorded_interactions
         end
       end
 
-      it "#{load_responses ? 'registers' : 'does not register'} the recorded responses with fakeweb when the record mode is #{record_mode}" do
+      it "#{load_interactions ? 'stubs' : 'does not stub'} the recorded requests with the http stubbing adapter when the record mode is #{record_mode}" do
         VCR::Config.cassette_library_dir = File.expand_path(File.dirname(__FILE__) + "/fixtures/#{RUBY_VERSION}/cassette_spec")
-        cassette = VCR::Cassette.new('example', :record => record_mode)
-
-        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, 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/
+        if load_interactions
+          VCR.http_stubbing_adapter.should_receive(:stub_requests).with([an_instance_of(VCR::HTTPInteraction)]*3)
         else
-          [rr1, rr2, rr3].compact.should have(0).responses
+          VCR.http_stubbing_adapter.should_receive(:stub_requests).never
         end
+
+        cassette = VCR::Cassette.new('example', :record => record_mode)
       end
     end
   end
@@ -144,66 +146,63 @@ describe VCR::Cassette do
   describe '#eject' do
     temp_dir File.expand_path(File.dirname(__FILE__) + '/fixtures/cassette_spec_eject'), :assign_to_cassette_library_dir => true
 
-    [true, false].each do |orig_allow_net_connect|
-      it "resets FakeWeb.allow_net_connect to #{orig_allow_net_connect} if it was originally #{orig_allow_net_connect}" do
-        FakeWeb.allow_net_connect = orig_allow_net_connect
+    [true, false].each do |orig_http_connections_allowed|
+      it "resets #{orig_http_connections_allowed} on the http stubbing adapter if it was originally #{orig_http_connections_allowed}" do
+        VCR.http_stubbing_adapter.should_receive(:http_connections_allowed?).and_return(orig_http_connections_allowed)
         cassette = VCR::Cassette.new(:name)
+        VCR.http_stubbing_adapter.should_receive(:http_connections_allowed=).with(orig_http_connections_allowed)
         cassette.eject
-        FakeWeb.allow_net_connect?.should == orig_allow_net_connect
       end
     end
 
-    it "writes the recorded responses to disk as yaml" do
-      recorded_responses = [
-        VCR::RecordedResponse.new(:get,  'http://example.com', :get_example_dot_come_response),
-        VCR::RecordedResponse.new(:post, 'http://example.com', :post_example_dot_come_response),
-        VCR::RecordedResponse.new(:get,  'http://google.com',  :get_google_dot_come_response)
+    it "writes the recorded interactions to disk as yaml" do
+      recorded_interactions = [
+        VCR::HTTPInteraction.new(:req_sig_1, :response_1),
+        VCR::HTTPInteraction.new(:req_sig_2, :response_2),
+        VCR::HTTPInteraction.new(:req_sig_3, :response_3)
       ]
 
       cassette = VCR::Cassette.new(:eject_test)
-      cassette.stub!(:recorded_responses).and_return(recorded_responses)
+      cassette.stub!(:recorded_interactions).and_return(recorded_interactions)
 
       lambda { cassette.eject }.should change { File.exist?(cassette.file) }.from(false).to(true)
-      saved_recorded_responses = File.open(cassette.file, "r") { |f| YAML.load(f.read) }
-      saved_recorded_responses.should == recorded_responses
+      saved_recorded_interactions = File.open(cassette.file, "r") { |f| YAML.load(f.read) }
+      saved_recorded_interactions.should == recorded_interactions
     end
 
-    it "writes the recorded responses to a subdirectory if the cassette name includes a directory" do
-      recorded_responses = [VCR::RecordedResponse.new(:get,  'http://example.com', :get_example_dot_come_response)]
+    it "writes the recorded interactions to a subdirectory if the cassette name includes a directory" do
+      recorded_interactions = [VCR::HTTPInteraction.new(:the_request, :the_response)]
       cassette = VCR::Cassette.new('subdirectory/test_cassette')
-      cassette.stub!(:recorded_responses).and_return(recorded_responses)
+      cassette.stub!(:recorded_interactions).and_return(recorded_interactions)
 
       lambda { cassette.eject }.should change { File.exist?(cassette.file) }.from(false).to(true)
-      saved_recorded_responses = File.open(cassette.file, "r") { |f| YAML.load(f.read) }
-      saved_recorded_responses.should == recorded_responses
+      saved_recorded_interactions = File.open(cassette.file, "r") { |f| YAML.load(f.read) }
+      saved_recorded_interactions.should == recorded_interactions
     end
 
-    it "writes both old and new recorded responses to disk" do
+    it "writes both old and new recorded interactions to disk" do
       file = File.expand_path(File.dirname(__FILE__) + "/fixtures/#{RUBY_VERSION}/cassette_spec/example.yml")
-      FileUtils.cp file, File.join(@temp_dir, 'previously_recorded_responses.yml')
-      cassette = VCR::Cassette.new('previously_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)
+      FileUtils.cp file, File.join(@temp_dir, 'previously_recorded_interactions.yml')
+      cassette = VCR::Cassette.new('previously_recorded_interactions')
+      cassette.should have(3).recorded_interactions
+      new_recorded_interaction = VCR::HTTPInteraction.new(:the_request, :the_response)
+      cassette.record_http_interaction(new_recorded_interaction)
       cassette.eject
-      saved_recorded_responses = File.open(cassette.file, "r") { |f| YAML.load(f.read) }
-      saved_recorded_responses.should have(4).recorded_responses
-      saved_recorded_responses.last.should == new_recorded_response
+      saved_recorded_interactions = File.open(cassette.file, "r") { |f| YAML.load(f.read) }
+      saved_recorded_interactions.should have(4).recorded_interactions
+      saved_recorded_interactions.last.should == new_recorded_interaction
     end
   end
 
-  describe '#eject for a cassette with previously recorded responses' do
-    it "de-registers the recorded responses from fakeweb" do
+  describe '#eject for a cassette with previously recorded interactions' do
+    it "restore the stubs checkpoint on the http stubbing adapter" do
       VCR::Config.cassette_library_dir = File.expand_path(File.dirname(__FILE__) + "/fixtures/#{RUBY_VERSION}/cassette_spec")
       cassette = VCR::Cassette.new('example', :record => :none)
-      FakeWeb.registered_uri?(:get, 'http://example.com').should be_true
-      FakeWeb.registered_uri?(:get, 'http://example.com/foo').should be_true
+      VCR.http_stubbing_adapter.should_receive(:restore_stubs_checkpoint).with('example')
       cassette.eject
-      FakeWeb.registered_uri?(:get, 'http://example.com').should be_false
-      FakeWeb.registered_uri?(:get, 'http://example.com/foo').should be_false
     end
 
-    it "does not re-write to disk the previously recorded resposes if there are no new ones" do
+    it "does not re-write to disk the previously recorded interactions if there are no new ones" do
       VCR::Config.cassette_library_dir = File.expand_path(File.dirname(__FILE__) + "/fixtures/#{RUBY_VERSION}/cassette_spec")
       yaml_file = File.join(VCR::Config.cassette_library_dir, 'example.yml')
       cassette = VCR::Cassette.new('example', :record => :none)
@@ -211,4 +210,4 @@ describe VCR::Cassette do
       lambda { cassette.eject }.should_not change { File.mtime(yaml_file) }
     end
   end
-end
+end

data/spec/config_spec.rb

@@ -19,4 +19,31 @@ describe VCR::Config do
       VCR::Config.default_cassette_options.should == {}
     end
   end
+
+  describe '#http_stubbing_library' do
+    it 'returns the configured value' do
+      [:fakeweb, :webmock].each do |setting|
+        VCR::Config.http_stubbing_library = setting
+        VCR::Config.http_stubbing_library.should == setting
+      end
+    end
+
+    context 'when set to nil' do
+      before(:each) { VCR::Config.http_stubbing_library = nil }
+
+      {
+        [:FakeWeb, :WebMock] => nil,
+        []                   => nil,
+        [:FakeWeb]           => :fakeweb,
+        [:WebMock]           => :webmock
+      }.each do |defined_constants, expected_return_value|
+        it "returns #{expected_return_value.inspect} when these constants are defined: #{defined_constants.inspect}" do
+          [:FakeWeb, :WebMock].each do |const|
+            Object.should_receive(:const_defined?).with(const).and_return(defined_constants.include?(const))
+          end
+          VCR::Config.http_stubbing_library.should == expected_return_value
+        end
+      end
+    end
+  end
 end

data/spec/extensions/net_http_spec.rb

@@ -16,35 +16,39 @@ describe "Net::HTTP Extensions" do
       @current_cassette.should_receive(:allow_real_http_requests_to?).at_least(:once).with(@uri).and_return(false)
     end
 
-    describe 'a request that is not registered with FakeWeb' do
+    describe 'a request that is not registered with the http stubbing adapter' do
+      before(:each) do
+        VCR.http_stubbing_adapter.should_receive(:request_stubbed?).with(anything, 'http://example.com:80/').and_return(false)
+      end
+
       def perform_get_with_returning_block
         Net::HTTP.new('example.com', 80).request(Net::HTTP::Get.new('/', {})) do |response|
           return response
         end
       end
 
-      it 'calls #store_recorded_response! on the current cassette' do
-        recorded_response = VCR::RecordedResponse.new(:get, 'http://example.com:80/', :example_response)
-        VCR::RecordedResponse.should_receive(:new).with(:get, 'http://example.com:80/', an_instance_of(Net::HTTPOK)).and_return(recorded_response)
-        @current_cassette.should_receive(:store_recorded_response!).with(recorded_response)
+      it 'calls #record_http_interaction on the current cassette' do
+        interaction = VCR::HTTPInteraction.new
+        VCR::HTTPInteraction.should_receive(:from_net_http_objects).and_return(interaction)
+        @current_cassette.should_receive(:record_http_interaction).with(interaction)
         Net::HTTP.get(@uri)
       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
+      it 'calls #record_http_interaction only once, even when Net::HTTP internally recursively calls #request' do
+        @current_cassette.should_receive(:record_http_interaction).once
         Net::HTTP.new('example.com', 80).post('/', nil)
       end
 
-      it 'calls #store_recorded_response! when Net::HTTP#request is called with a block with a return statement' do
-        @current_cassette.should_receive(:store_recorded_response!).once
+      it 'calls #record_http_interaction when Net::HTTP#request is called with a block with a return statement' do
+        @current_cassette.should_receive(:record_http_interaction).once
         perform_get_with_returning_block
       end
     end
 
-    describe 'a request that is registered with FakeWeb' do
-      it 'does not call #store_recorded_response! on the current cassette' do
-        FakeWeb.register_uri(:get, 'http://example.com', :body => 'example.com response')
-        @current_cassette.should_not_receive(:store_recorded_response!)
+    describe 'a request that is registered with the http stubbing adapter' do
+      it 'does not call #record_http_interaction on the current cassette' do
+        VCR.http_stubbing_adapter.should_receive(:request_stubbed?).with(:get, 'http://example.com:80/').and_return(true)
+        @current_cassette.should_not_receive(:record_http_interaction)
         Net::HTTP.get(@uri)
       end
     end
@@ -55,13 +59,13 @@ describe "Net::HTTP Extensions" do
       @current_cassette.should_receive(:allow_real_http_requests_to?).with(@uri).and_return(true)
     end
 
-    it 'does not call #store_recorded_response! on the current cassette' do
-      @current_cassette.should_receive(:store_recorded_response!).never
+    it 'does not call #record_http_interaction on the current cassette' do
+      @current_cassette.should_receive(:record_http_interaction).never
       Net::HTTP.get(@uri)
     end
 
-    it 'uses FakeWeb.with_allow_net_connect_set_to(true) to make the request' do
-      FakeWeb.should_receive(:with_allow_net_connect_set_to).with(true).and_yield
+    it 'uses VCR.http_stubbing_adapter.with_http_connections_allowed_set_to(true) to make the request' do
+      VCR.http_stubbing_adapter.should_receive(:with_http_connections_allowed_set_to).with(true).and_yield
       Net::HTTP.get(@uri)
     end
   end

data/spec/fixtures/1.8.6/0_3_1_cassette.yml

@@ -0,0 +1,29 @@
+--- 
+- !ruby/struct:VCR::RecordedResponse 
+  method: :post
+  uri: http://example.com:80/
+  response: !ruby/object:Net::HTTPOK 
+    body: The response from example.com
+    body_exist: true
+    code: "200"
+    header: 
+      etag: 
+      - "\"24ec5-1b6-4059a80bfd280\""
+      last-modified: 
+      - Tue, 15 Nov 2005 13:24:10 GMT
+      content-type: 
+      - text/html; charset=UTF-8
+      connection: 
+      - close
+      server: 
+      - Apache/2.2.3 (CentOS)
+      date: 
+      - Wed, 31 Mar 2010 02:43:26 GMT
+      content-length: 
+      - "438"
+      accept-ranges: 
+      - bytes
+    http_version: "1.1"
+    message: OK
+    read: true
+    socket: