vcr 1.3.3 → 1.4.0

data/spec/fixtures/1.9.1/fake_example.com_responses.yml

@@ -1,33 +1,4 @@
 --- 
-- !ruby/struct:VCR::HTTPInteraction 
-  :request: !ruby/struct:VCR::Request 
-    :method: :post
-    :uri: http://example.com:80/
-    :body: 
-    :headers: 
-  :response: !ruby/struct:VCR::Response 
-    :status: !ruby/struct:VCR::ResponseStatus 
-      :code: 200
-      :message: OK
-    :headers: 
-      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
-    :body: example.com post response with id=7
-    :http_version: "1.1"
 - !ruby/struct:VCR::HTTPInteraction 
   :request: !ruby/struct:VCR::Request 
     :method: :get

data/spec/fixtures/1.9.1/match_requests_on.yml

@@ -155,7 +155,7 @@
     :uri: http://example.com:80/
     :body: 
     :headers: 
-      :x-http-header1: 
+      x-http-header1: 
       - val1
   :response: !ruby/struct:VCR::Response 
     :status: !ruby/struct:VCR::ResponseStatus 
@@ -172,7 +172,7 @@
     :uri: http://example.com:80/
     :body: 
     :headers: 
-      :x-http-header1: 
+      x-http-header1: 
       - val2
   :response: !ruby/struct:VCR::Response 
     :status: !ruby/struct:VCR::ResponseStatus 

data/spec/fixtures/not_1.9.1/fake_example.com_responses.yml

@@ -1,33 +1,4 @@
 --- 
-- !ruby/struct:VCR::HTTPInteraction 
-  request: !ruby/struct:VCR::Request 
-    method: :post
-    uri: http://example.com:80/
-    body: 
-    headers: 
-  response: !ruby/struct:VCR::Response 
-    status: !ruby/struct:VCR::ResponseStatus 
-      code: 200
-      message: OK
-    headers: 
-      last-modified: 
-      - Tue, 15 Nov 2005 13:24:10 GMT
-      connection: 
-      - close
-      etag: 
-      - "\"24ec5-1b6-4059a80bfd280\""
-      content-type: 
-      - text/html; charset=UTF-8
-      date: 
-      - Wed, 31 Mar 2010 02:43:26 GMT
-      server: 
-      - Apache/2.2.3 (CentOS)
-      content-length: 
-      - "438"
-      accept-ranges: 
-      - bytes
-    body: example.com post response with id=7
-    http_version: "1.1"
 - !ruby/struct:VCR::HTTPInteraction 
   request: !ruby/struct:VCR::Request 
     method: :get

data/spec/http_stubbing_adapters/faraday_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe VCR::HttpStubbingAdapters::Faraday do
+  without_monkey_patches :all
+
+  it_behaves_like 'an http stubbing adapter',
+    %w[ faraday-typhoeus faraday-net_http faraday-patron ],
+    [:method, :uri, :host, :path, :body, :headers],
+    :status_message_not_exposed, :does_not_support_rotating_responses
+
+  it_performs('version checking',
+    :valid    => %w[ 0.5.3 0.5.10 ],
+    :too_low  => %w[ 0.5.2 0.4.99 ],
+    :too_high => %w[ 0.6.0 1.0.0 ]
+  ) do
+    disable_warnings
+    before(:each) { @orig_version = Faraday::VERSION }
+    after(:each)  { Faraday::VERSION = @orig_version }
+
+    # Cannot be regular method def as that raises a "dynamic constant assignment" error
+    define_method :stub_version do |version|
+      ::Faraday::VERSION = version
+    end
+  end
+
+  context 'when some request have been stubbed' do
+    subject { described_class }
+    let(:request_1) { VCR::Request.new(:get, 'http://foo.com') }
+    let(:request_2) { VCR::Request.new(:get, 'http://bazz.com') }
+    let(:match_attributes) { [:method, :uri] }
+
+    def stubbed_response_for(request)
+      matcher = VCR::RequestMatcher.new(request, match_attributes)
+      subject.stubbed_response_for(matcher)
+    end
+
+    before(:each) do
+      subject.stub_requests(
+        [
+          VCR::HTTPInteraction.new(request_1, :response_1),
+          VCR::HTTPInteraction.new(request_1, :response_2),
+        ], match_attributes
+      )
+    end
+
+    def test_stubbed_responses
+      stubbed_response_for(request_1).should == :response_1
+      stubbed_response_for(request_1).should == :response_2
+      stubbed_response_for(request_1).should == :response_2
+      stubbed_response_for(request_1).should == :response_2
+    end
+
+    describe '.stubbed_response_for' do
+      it 'returns nil when there is no matching response' do
+        stubbed_response_for(request_2).should be_nil
+      end
+
+      it 'dequeues each response and continues to return the last one' do
+        test_stubbed_responses
+      end
+    end
+
+    describe '.restore_stubs_checkpoints' do
+      before(:each) do
+        subject.create_stubs_checkpoint(:checkpoint_1)
+      end
+
+      it 'restores the queues to the checkpoint state when a queue has additional responses' do
+        subject.stub_requests( [
+          VCR::HTTPInteraction.new(request_1, :response_3),
+        ], match_attributes)
+
+        subject.restore_stubs_checkpoint(:checkpoint_1)
+        test_stubbed_responses
+      end
+
+      it 'restores the queues to the checkpoint state when a queue has been used' do
+        stubbed_response_for(request_1)
+        subject.restore_stubs_checkpoint(:checkpoint_1)
+        test_stubbed_responses
+      end
+    end
+  end
+end

data/spec/middleware/cassette_arguments_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe VCR::Middleware::CassetteArguments do
+  describe '#name' do
+    it 'initially returns nil' do
+      subject.name.should be_nil
+    end
+
+    it 'stores the given value, returning it when no arg is given' do
+      subject.name :value1
+      subject.name.should == :value1
+
+      subject.name :value2
+      subject.name.should == :value2
+    end
+  end
+
+  describe '#options' do
+    it 'initially returns an empty hash' do
+      subject.options.should == {}
+    end
+
+    it 'merges the given hash options, returning them when no arg is given' do
+      subject.options :record => :new_episodes
+      subject.options.should == { :record => :new_episodes }
+
+      subject.options :erb => true
+      subject.options.should == { :record => :new_episodes, :erb => true }
+    end
+  end
+end
+

data/spec/middleware/faraday_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe VCR::Middleware::Faraday do
+  describe '.new' do
+    it 'raises an error if no cassette arguments block is provided' do
+      expect {
+        described_class.new(lambda { |env| })
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#call' do
+    let(:env_hash) { { :url => 'http://localhost:3000/' } }
+
+    before(:each) do
+      VCR::HttpStubbingAdapters::Faraday.ignore_localhost = true
+    end
+
+    it 'uses a cassette when the app is called' do
+      VCR.current_cassette.should be_nil
+      app = lambda { |env| VCR.current_cassette.should_not be_nil }
+      instance = described_class.new(app) { |c| c.name 'cassette_name' }
+      instance.call(env_hash)
+      VCR.current_cassette.should be_nil
+    end
+
+    it 'sets the cassette name based on the provided block' do
+      app = lambda { |env| VCR.current_cassette.name.should == 'rack_cassette' }
+      instance = described_class.new(app) { |c| c.name 'rack_cassette' }
+      instance.call(env_hash)
+    end
+
+    it 'sets the cassette options based on the provided block' do
+      app = lambda { |env| VCR.current_cassette.erb.should == { :foo => :bar } }
+      instance = described_class.new(app) do |c|
+        c.name    'c'
+        c.options :erb => { :foo => :bar }
+      end
+
+      instance.call(env_hash)
+    end
+
+    it 'yields the env to the provided block when the block accepts 2 arguments' do
+      instance = described_class.new(lambda { |env| }) do |c, env|
+        env.should == env_hash
+        c.name    'c'
+      end
+
+      instance.call(env_hash)
+    end
+  end
+end

data/spec/middleware/rack_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe VCR::Middleware::Rack do
+  describe '.new' do
+    it 'raises an error if no cassette arguments block is provided' do
+      expect {
+        described_class.new(lambda { |env| })
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#call' do
+    let(:env_hash) { { :env => :hash } }
+    it 'calls the provided rack app and returns its response' do
+      rack_app = mock
+      rack_app.should_receive(:call).with(env_hash).and_return(:response)
+      instance = described_class.new(rack_app) { |c| c.name 'cassette_name' }
+      instance.call(env_hash).should == :response
+    end
+
+    it 'uses a cassette when the rack app is called' do
+      VCR.current_cassette.should be_nil
+      rack_app = lambda { |env| VCR.current_cassette.should_not be_nil }
+      instance = described_class.new(rack_app) { |c| c.name 'cassette_name' }
+      instance.call({})
+      VCR.current_cassette.should be_nil
+    end
+
+    it 'sets the cassette name based on the provided block' do
+      rack_app = lambda { |env| VCR.current_cassette.name.should == 'rack_cassette' }
+      instance = described_class.new(rack_app) { |c| c.name 'rack_cassette' }
+      instance.call({})
+    end
+
+    it 'sets the cassette options based on the provided block' do
+      rack_app = lambda { |env| VCR.current_cassette.erb.should == { :foo => :bar } }
+      instance = described_class.new(rack_app) do |c|
+        c.name    'c'
+        c.options :erb => { :foo => :bar }
+      end
+
+      instance.call({})
+    end
+
+    it 'yields the rack env to the provided block when the block accepts 2 arguments' do
+      instance = described_class.new(lambda { |env| }) do |c, env|
+        env.should == env_hash
+        c.name    'c'
+      end
+
+      instance.call(env_hash)
+    end
+  end
+end

data/spec/monkey_patches.rb

@@ -95,6 +95,7 @@ if RUBY_INTERPRETER == :mri
   require 'patron'
   require 'em-http-request'
   require 'curb'
+  require 'typhoeus'
 end
 
 # The FakeWeb adapter must be required after WebMock's so

data/spec/request_matcher_spec.rb

@@ -145,6 +145,10 @@ describe VCR::RequestMatcher do
     return matcher, matcher(attribute)
   end
 
+  def matcher_with_headers(headers)
+    VCR::RequestMatcher.new(VCR::Request.new(:get, 'http://foo.com/', nil, headers), [:method, :uri, :headers])
+  end
+
   describe '#hash' do
     it 'returns the same code for two objects when #match_attributes, #method, #uri, #body and #headers are the same, even when the request object is different' do
       m1, m2 = matchers_varying_on(:request)
@@ -164,6 +168,38 @@ describe VCR::RequestMatcher do
         m1.hash.should_not == m2.hash
       end
     end
+
+    context 'for headers' do
+      it 'returns the same code for the same headers' do
+        m1 = matcher_with_headers('x-http-header' => ['val1'])
+        m2 = matcher_with_headers('x-http-header' => ['val1'])
+        m1.hash.should == m2.hash
+      end
+
+      it 'returns the same code when the header keys are ordered differently' do
+        m1 = matcher_with_headers('x-http-header1' => ['val1'], 'x-http-header2' => ['val2'])
+        m2 = matcher_with_headers('x-http-header2' => ['val2'], 'x-http-header1' => ['val1'])
+        m1.hash.should == m2.hash
+      end
+
+      it 'returns the same code when the header value arrays are ordered differently' do
+        m1 = matcher_with_headers('x-http-header' => ['val1', 'val2'])
+        m2 = matcher_with_headers('x-http-header' => ['val2', 'val1'])
+        m1.hash.should == m2.hash
+      end
+
+      it 'returns a different code when the header values are different' do
+        m1 = matcher_with_headers('x-http-header' => ['val1'])
+        m2 = matcher_with_headers('x-http-header' => ['val2'])
+        m1.hash.should_not == m2.hash
+      end
+
+      it 'returns a different code when the header keys are different' do
+        m1 = matcher_with_headers('x-http-header1' => ['val1'])
+        m2 = matcher_with_headers('x-http-header2' => ['val1'])
+        m1.hash.should_not == m2.hash
+      end
+    end
   end
 
   [:eql?, :==].each do |equality_method|

data/spec/spec_helper.rb

@@ -24,6 +24,9 @@ RSpec.configure do |config|
   config.debug = RUBY_INTERPRETER == :mri
 
   config.before(:each) do
+    VCR.turn_on! unless VCR.turned_on?
+    VCR.eject_cassette while VCR.current_cassette
+
     VCR::Config.default_cassette_options = { :record => :new_episodes }
     VCR::Config.stub_with :fakeweb
 
@@ -32,6 +35,8 @@ RSpec.configure do |config|
 
     FakeWeb.allow_net_connect = true
     FakeWeb.clean_registry
+
+    VCR::HttpStubbingAdapters::Faraday.reset!
   end
 
   config.filter_run :focus => true
@@ -40,3 +45,8 @@ RSpec.configure do |config|
   config.alias_it_should_behave_like_to :it_performs, 'it performs'
 end
 
+http_stubbing_dir = File.join(File.dirname(__FILE__), '..', 'lib', 'vcr', 'http_stubbing_adapters')
+Dir[File.join(http_stubbing_dir, '*.rb')].each do |file|
+  next if RUBY_INTERPRETER != :mri && file =~ /(typhoeus)/
+  require "vcr/http_stubbing_adapters/#{File.basename(file)}"
+end

data/spec/support/http_library_adapters.rb

@@ -112,12 +112,68 @@ HTTP_LIBRARY_ADAPTERS['typhoeus'] = Module.new do
   end
 end
 
+%w[ net_http typhoeus patron ].each do |_faraday_adapter|
+  HTTP_LIBRARY_ADAPTERS["faraday-#{_faraday_adapter}"] = Module.new do
+    class << self; self; end.class_eval do
+      define_method(:http_library_name) do
+        "Faraday (#{_faraday_adapter})"
+      end
+    end
+
+    define_method(:faraday_adapter) { _faraday_adapter.to_sym }
+
+    def get_body_string(response)
+      response.body
+    end
+
+    def get_header(header_key, response)
+      response.headers[header_key]
+    end
+
+    def make_http_request(method, url, body = nil, headers = {})
+      url_root, url_rest = split_url(url)
+
+      faraday_connection(url_root).send(method) do |req|
+        req.url url_rest
+        headers.each { |k, v| req[k] = v }
+        req.body = body if body
+      end
+    end
+
+    def split_url(url)
+      uri = URI.parse(url)
+      url_root = "#{uri.scheme}://#{uri.host}:#{uri.port}"
+      rest = url.sub(url_root, '')
+
+      [url_root, rest]
+    end
+
+    def faraday_connection(url_root)
+      Faraday::Connection.new(:url => url_root) do |builder|
+        builder.use VCR::Middleware::Faraday do |cassette|
+          cassette.name    'faraday_example'
+
+          if respond_to?(:match_requests_on)
+            cassette.options :match_requests_on => match_requests_on
+          end
+
+          if respond_to?(:record_mode)
+            cassette.options :record => record_mode
+          end
+        end
+
+        builder.adapter faraday_adapter
+      end
+    end
+  end
+end
+
 NET_CONNECT_NOT_ALLOWED_ERROR = /You can use VCR to automatically record this request and replay it later/
 
 module HttpLibrarySpecs
   def test_http_library(library, supported_request_match_attributes, *other)
-    # curb, patron and em-http-client cannot be installed on jruby
-    return if %w[curb patron em-http-request].include?(library) && RUBY_INTERPRETER != :mri
+    # skip libs that only work on MRI
+    return if RUBY_INTERPRETER != :mri && library =~ /(typhoeus|curb|patron|em-http)/
 
     unless adapter_module = HTTP_LIBRARY_ADAPTERS[library]
       raise ArgumentError.new("No http library adapter module could be found for #{library}")
@@ -139,7 +195,9 @@ module HttpLibrarySpecs
           supported_request_match_attributes = @supported_request_match_attributes
 
           describe ":#{attribute}" do
-            let(:perform_stubbing) { subject.stub_requests(interactions, [attribute]) }
+            let(:perform_stubbing) { subject.stub_requests(interactions, match_requests_on) }
+            let(:match_requests_on) { [attribute] }
+            let(:record_mode) { :none }
 
             if supported_request_match_attributes.include?(attribute)
               before(:each) { perform_stubbing }
@@ -199,7 +257,7 @@ module HttpLibrarySpecs
         end
       end
 
-      def self.test_real_http_request(http_allowed)
+      def self.test_real_http_request(http_allowed, *other)
         let(:url) { "http://localhost:#{VCR::SinatraApp.port}/foo" }
 
         if http_allowed
@@ -208,20 +266,55 @@ module HttpLibrarySpecs
             get_body_string(make_http_request(:get, url)).should == 'FOO!'
           end
 
-          it 'records new http requests' do
-            VCR.should_receive(:record_http_interaction) do |interaction|
-              interaction.request.uri.should == url
-              interaction.request.method.should == :get
-              interaction.response.status.code.should == 200
-              interaction.response.status.message.should == 'OK'
-              interaction.response.body.should == 'FOO!'
-              interaction.response.headers['content-type'].should == ["text/html;charset=utf-8"]
+          describe 'recording new http requests' do
+            let(:recorded_interaction) do
+              interaction = nil
+              VCR.should_receive(:record_http_interaction) { |i| interaction = i }
+              make_http_request(:get, url)
+              interaction
             end
 
-            make_http_request(:get, url)
-          end
+            it 'does not record the request if the adapter is disabled' do
+              subject.stub(:enabled?).and_return(false)
+              VCR.should_not_receive(:record_http_interaction)
+              make_http_request(:get, url)
+            end
+
+            it 'records the request uri' do
+              recorded_interaction.request.uri.should == url
+            end
+
+            it 'records the request method' do
+              recorded_interaction.request.method.should == :get
+            end
+
+            it 'records the request body' do
+              recorded_interaction.request.body.should be_nil
+            end
+
+            it 'records the request headers' do
+              recorded_interaction.request.headers.should be_nil
+            end
+
+            it 'records the response status code' do
+              recorded_interaction.response.status.code.should == 200
+            end
+
+            it 'records the response status message' do
+              recorded_interaction.response.status.message.should == 'OK'
+            end unless other.include?(:status_message_not_exposed)
+
+            it 'records the response body' do
+              recorded_interaction.response.body.should == 'FOO!'
+            end
 
+            it 'records the response headers' do
+              recorded_interaction.response.headers['content-type'].should == ["text/html;charset=utf-8"]
+            end
+          end
         else
+          let(:record_mode) { :none }
+
           it 'does not allow real HTTP requests or record them' do
             VCR.should_receive(:record_http_interaction).never
             expect { make_http_request(:get, url) }.to raise_error(NET_CONNECT_NOT_ALLOWED_ERROR)
@@ -246,11 +339,12 @@ module HttpLibrarySpecs
             subject.http_connections_allowed?.should == http_allowed
           end
 
-          test_real_http_request(http_allowed)
+          test_real_http_request(http_allowed, *other)
 
           unless http_allowed
             describe '.ignore_localhost =' do
               localhost_response = "Localhost response"
+              let(:record_mode) { :none }
 
               VCR::LOCALHOST_ALIASES.each do |localhost_alias|
                 describe 'when set to true' do
@@ -291,15 +385,9 @@ module HttpLibrarySpecs
               end
             end
 
-            it 'gets the stubbed responses when multiple post requests are made to http://example.com, and does not record them' do
-              VCR.should_receive(:record_http_interaction).never
-              get_body_string(make_http_request(:post, 'http://example.com/', { 'id' => '7' })).should == 'example.com post response with id=7'
-              get_body_string(make_http_request(:post, 'http://example.com/', { 'id' => '3' })).should == 'example.com post response with id=3'
-            end
-
             it 'gets the stubbed responses when requests are made to http://example.com/foo, and does not record them' do
               VCR.should_receive(:record_http_interaction).never
-              get_body_string(make_http_request(:get, 'http://example.com/foo')).should == 'example.com get response 1 with path=foo'
+              get_body_string(make_http_request(:get, 'http://example.com/foo')).should =~ /example\.com get response \d with path=foo/
             end
 
             it 'rotates through multiple responses for the same request' do
@@ -309,16 +397,16 @@ module HttpLibrarySpecs
               # subsequent requests keep getting the last one
               get_body_string(make_http_request(:get, 'http://example.com/foo')).should == 'example.com get response 2 with path=foo'
               get_body_string(make_http_request(:get, 'http://example.com/foo')).should == 'example.com get response 2 with path=foo'
-            end
+            end unless other.include?(:does_not_support_rotating_responses)
 
             it "correctly handles stubbing multiple values for the same header" do
-                get_header('Set-Cookie', make_http_request(:get, 'http://example.com/two_set_cookie_headers')).should =~ ['bar=bazz', 'foo=bar']
+              get_header('Set-Cookie', make_http_request(:get, 'http://example.com/two_set_cookie_headers')).should =~ ['bar=bazz', 'foo=bar']
             end
 
             context 'when we restore our previous check point' do
               before(:each) { subject.restore_stubs_checkpoint(:my_checkpoint) }
 
-              test_real_http_request(http_allowed)
+              test_real_http_request(http_allowed, *other)
 
               if other.include?(:needs_net_http_extension)
                 it 'returns false from #request_stubbed?' do