vcr 1.1.0 → 1.1.1

data/spec/config_spec.rb

@@ -0,0 +1,76 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe VCR::Config do
+  describe '#cassette_library_dir=' do
+    temp_dir(File.expand_path(File.dirname(__FILE__) + '/fixtures/config_spec'))
+
+    it 'creates the directory if it does not exist' do
+      lambda { VCR::Config.cassette_library_dir = @temp_dir }.should change { File.exist?(@temp_dir) }.from(false).to(true)
+    end
+
+    it 'does not raise an error if given nil' do
+      lambda { VCR::Config.cassette_library_dir = nil }.should_not raise_error
+    end
+  end
+
+  describe '#default_cassette_options' do
+    it 'has a hash with some defaults even if it is set to nil' do
+      VCR::Config.default_cassette_options = nil
+      VCR::Config.default_cassette_options.should == { :match_requests_on => VCR::RequestMatcher::DEFAULT_MATCH_ATTRIBUTES }
+    end
+
+    it "returns #{VCR::RequestMatcher::DEFAULT_MATCH_ATTRIBUTES.inspect} for :match_requests_on when other defaults have been set" do
+      VCR::Config.default_cassette_options = { :record => :none }
+      VCR::Config.default_cassette_options.should == {
+        :record            => :none,
+        :match_requests_on => VCR::RequestMatcher::DEFAULT_MATCH_ATTRIBUTES
+      }
+    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
+
+  describe '#ignore_localhost' do
+    it 'sets VCR.http_stubbing_adapter.ignore_localhost?' do
+      [true, false].each do |val|
+        VCR.http_stubbing_adapter.ignore_localhost = !val
+        expect {
+          VCR::Config.ignore_localhost = val
+        }.to change { VCR.http_stubbing_adapter.ignore_localhost? }.from(!val).to(val)
+      end
+    end
+
+    it 'stores the value even when VCR.http_stubbing_adapter is nil' do
+      VCR.stub!(:http_stubbing_adapter).and_return(nil)
+      [true, false].each do |val|
+        VCR::Config.ignore_localhost = val
+        VCR::Config.ignore_localhost?.should == val
+      end
+    end
+  end
+end

data/spec/cucumber_tags_spec.rb

@@ -0,0 +1,55 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe VCR::CucumberTags do
+  subject { described_class.new(self) }
+  let(:blocks_for_tags) { {} }
+
+  # define our own Around so we can test this in isolation from cucumber's implementation.
+  def Around(tag, &block)
+    blocks_for_tags[tag.sub('@', '')] = block
+  end
+
+  def test_tag(cassette_attribute, tag, expected_value)
+    VCR.current_cassette.should be_nil
+
+    cassette_during_scenario, scenario = nil, lambda { cassette_during_scenario = VCR.current_cassette }
+    blocks_for_tags[tag].call(:scenario_name, scenario)
+    cassette_during_scenario.send(cassette_attribute).should == expected_value
+
+    VCR.current_cassette.should be_nil
+  end
+
+  %w(tags tag).each do |tag_method|
+    describe "##{tag_method}" do
+      it "creates a cucumber Around hook for each given tag so that the scenario runs with the cassette inserted" do
+        subject.send(tag_method, 'tag1', 'tag2')
+
+        test_tag(:name, 'tag1', 'cucumber_tags/tag1')
+        test_tag(:name, 'tag2', 'cucumber_tags/tag2')
+      end
+
+      it "works with tags that start with an @" do
+        subject.send(tag_method, '@tag1', '@tag2')
+
+        test_tag(:name, 'tag1', 'cucumber_tags/tag1')
+        test_tag(:name, 'tag2', 'cucumber_tags/tag2')
+      end
+
+      it "passes along the given options to the cassette" do
+        subject.send(tag_method, 'tag1', :record => :none)
+        subject.send(tag_method, 'tag2', :record => :new_episodes)
+
+        test_tag(:record_mode, 'tag1', :none)
+        test_tag(:record_mode, 'tag2', :new_episodes)
+      end
+    end
+  end
+
+  describe '.tags' do
+    it 'returns the list of cucumber tags' do
+      subject.tags 'tag1', 'tag2'
+      subject.tags 'tag3', 'tag4'
+      described_class.tags[-4, 4].should == %w(@tag1 @tag2 @tag3 @tag4)
+    end
+  end
+end

data/spec/deprecations_spec.rb

@@ -0,0 +1,52 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe 'Deprecations' do
+  describe VCR::Cassette do
+    disable_warnings
+    subject { VCR::Cassette.new('cassette name') }
+
+    it 'raises an error when an :allow_real_http lambda is given' do
+      expect { VCR::Cassette.new('cassette name', :allow_real_http => lambda {}) }.to raise_error(ArgumentError)
+    end
+
+    it "prints a warning: WARNING: VCR::Cassette#allow_real_http_requests_to? is deprecated and should no longer be used" do
+      subject.should_receive(:warn).with("WARNING: VCR::Cassette#allow_real_http_requests_to? is deprecated and should no longer be used.")
+      subject.allow_real_http_requests_to?(URI.parse('http://example.org'))
+    end
+
+    [true, false].each do |orig_ignore_localhost|
+      context "when the http_stubbing_adapter's ignore_localhost is set to #{orig_ignore_localhost}" do
+        before(:each) { VCR.http_stubbing_adapter.ignore_localhost = orig_ignore_localhost }
+
+        context 'when the :allow_real_http option is set to :localhost' do
+          subject { VCR::Cassette.new('cassette name', :allow_real_http => :localhost) }
+
+          it "sets the http_stubbing_adapter's ignore_localhost attribute to true" do
+            subject
+            VCR.http_stubbing_adapter.ignore_localhost?.should be_true
+          end
+
+          it "prints a warning: VCR's :allow_real_http cassette option is deprecated.  Instead, use the ignore_localhost configuration option." do
+            Kernel.should_receive(:warn).with("WARNING: VCR's :allow_real_http cassette option is deprecated.  Instead, use the ignore_localhost configuration option.")
+            subject
+          end
+
+          it "reverts ignore_localhost when the cassette is ejected" do
+            subject.eject
+            VCR.http_stubbing_adapter.ignore_localhost?.should == orig_ignore_localhost
+          end
+
+          {
+            'http://localhost'   => true,
+            'http://127.0.0.1'   => true,
+            'http://example.com' => false
+          }.each do |url, expected_value|
+            it "returns #{expected_value} for #allow_real_http_requests_to? when it is given #{url}" do
+              subject.allow_real_http_requests_to?(URI.parse(url)).should == expected_value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/extensions/net_http_response_spec.rb

@@ -0,0 +1,85 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Net::HTTP Response extensions" do
+  context 'extending an already read response' do
+    # WebMock uses this extension, too, and to prevent it from automatically being included
+    # (and hence, causing issues with this spec), we remove all callbacks for the duration
+    # of this spec, since the absence of any callbacks will prevent WebMock from reading the response
+    # and extending the response with the response extension.
+    before(:all) do
+      @orig_webmock_callbacks = ::WebMock::CallbackRegistry.callbacks.dup
+      ::WebMock::CallbackRegistry.reset
+    end
+
+    after(:all) do
+      @orig_webmock_callbacks.each do |cb|
+        ::WebMock::CallbackRegistry.add_callback(cb[:options], cb[:block])
+      end
+    end
+
+    def self.it_allows_the_body_to_be_read_again
+      subject { @response.clone }
+      let(:expected_regex) { /You have reached this web page by typing.*example\.com/ }
+
+      it 'allows the body to be read using #body' do
+        subject.body.to_s.should =~ expected_regex
+      end
+
+      it 'allows the body to be read using #read_body' do
+        subject.read_body.to_s.should =~ expected_regex
+      end
+
+      it 'allows the body to be read using #read_body with a block' do
+        yielded_body = ''
+        ret_val = subject.read_body { |s| yielded_body << s }
+        yielded_body.should =~ expected_regex
+        ret_val.should be_instance_of(Net::ReadAdapter)
+      end
+
+      it 'allows the body to be read by passing a destination string to #read_body' do
+        dest = ''
+        ret_val = subject.read_body(dest)
+        dest.should =~ expected_regex
+        ret_val.should == dest
+      end
+
+      it 'raises an ArgumentError if both a destination string and a block is given to #read_body' do
+        dest = ''
+        expect { subject.read_body(dest) { |s| } }.should raise_error(ArgumentError, 'both arg and block given for HTTP method')
+      end
+
+      it 'raises an IOError when #read_body is called twice with a block' do
+        subject.read_body { |s| }
+        expect { subject.read_body { |s| } }.to raise_error(IOError, /read_body called twice/)
+      end
+
+      it 'raises an IOError when #read_body is called twice with a destination string' do
+        dest = ''
+        subject.read_body(dest)
+        expect { subject.read_body(dest) }.to raise_error(IOError, /read_body called twice/)
+      end
+    end
+
+    context 'when the body has already been read using #read_body and a dest string' do
+      before(:each) do
+        http = Net::HTTP.new('example.com', 80)
+        dest = ''
+        @response = http.request_get('/') { |res| res.read_body(dest) }
+        @response.extend VCR::Net::HTTPResponse
+      end
+
+      it_allows_the_body_to_be_read_again
+    end
+
+    context 'when the body has already been read using #body' do
+      before(:each) do
+        http = Net::HTTP.new('example.com', 80)
+        @response = http.request_get('/')
+        @response.body
+        @response.extend VCR::Net::HTTPResponse
+      end
+
+      it_allows_the_body_to_be_read_again
+    end
+  end
+end

data/spec/extensions/net_http_spec.rb

@@ -0,0 +1,77 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Net::HTTP Extensions" do
+  let(:uri) { URI.parse('http://example.com') }
+
+  it 'checks if the request is stubbed using a VCR::Request' do
+    VCR.http_stubbing_adapter.should_receive(:request_stubbed?) do |request, _|
+      request.uri.should == 'http://example.com:80/'
+      request.method.should == :get
+      true
+    end
+    Net::HTTP.get(uri)
+  end
+
+  it "checks if the request is stubbed using the current VCR cassette's match_request_on option" do
+    VCR.should_receive(:current_cassette).and_return(stub(:match_requests_on => [:body, :header]))
+    VCR.http_stubbing_adapter.should_receive(:request_stubbed?).with(anything, [:body, :header]).and_return(true)
+    Net::HTTP.get(uri)
+  end
+
+  it "checks if the request is stubbed using the default match attributes when there is no current cassette" do
+    VCR.should_receive(:current_cassette).and_return(nil)
+    VCR.http_stubbing_adapter.should_receive(:request_stubbed?).with(anything, VCR::RequestMatcher::DEFAULT_MATCH_ATTRIBUTES).and_return(true)
+    Net::HTTP.get(uri)
+  end
+
+  describe 'a request that is not registered with the http stubbing adapter' do
+    before(:each) do
+      VCR.http_stubbing_adapter.stub(:request_stubbed?).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 "does not record headers for which Net::HTTP sets defaults near the end of the real request" do
+      VCR.should_receive(:record_http_interaction) do |interaction|
+        interaction.request.headers.should_not have_key('content-type')
+        interaction.request.headers.should_not have_key('host')
+      end
+      Net::HTTP.new('example.com', 80).send_request('POST', '/', '', {})
+    end
+
+    it "records headers for which Net::HTTP usually sets defaults when the user manually sets their values" do
+      VCR.should_receive(:record_http_interaction) do |interaction|
+        interaction.request.headers['content-type'].should == ['foo/bar']
+        interaction.request.headers['host'].should == ['my-example.com']
+      end
+      Net::HTTP.new('example.com', 80).send_request('POST', '/', '', { 'Content-Type' => 'foo/bar', 'Host' => 'my-example.com' })
+    end
+
+    it 'calls VCR.record_http_interaction' do
+      VCR.should_receive(:record_http_interaction).with(instance_of(VCR::HTTPInteraction))
+      Net::HTTP.get(uri)
+    end
+
+    it 'calls #record_http_interaction only once, even when Net::HTTP internally recursively calls #request' do
+      VCR.should_receive(:record_http_interaction).once
+      Net::HTTP.new('example.com', 80).post('/', nil)
+    end
+
+    it 'calls #record_http_interaction when Net::HTTP#request is called with a block with a return statement' do
+      VCR.should_receive(:record_http_interaction).once
+      perform_get_with_returning_block
+    end
+  end
+
+  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.stub(:request_stubbed?).and_return(true)
+      VCR.should_receive(:record_http_interaction).never
+      Net::HTTP.get(uri)
+    end
+  end
+end

data/spec/fixtures/1.9.1/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: 

data/spec/fixtures/1.9.1/cassette_spec/erb_with_no_vars.yml

@@ -0,0 +1,32 @@
+--- 
+- !ruby/struct:VCR::HTTPInteraction 
+  :request: !ruby/struct:VCR::Request 
+    :method: :get
+    :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
+      connection: 
+      - Keep-Alive
+      content-type: 
+      - text/html; charset=UTF-8
+      date: 
+      - Thu, 25 Feb 2010 07:53:51 GMT
+      server: 
+      - Apache/2.2.3 (CentOS)
+      content-length: 
+      - "438"
+      age: 
+      - "9260"
+      accept-ranges: 
+      - bytes
+    :body: "sum: <%= 1 + 2 %>"
+    :http_version: "1.1"

data/spec/fixtures/1.9.1/cassette_spec/erb_with_vars.yml

@@ -0,0 +1,32 @@
+--- 
+- !ruby/struct:VCR::HTTPInteraction 
+  :request: !ruby/struct:VCR::Request 
+    :method: :get
+    :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
+      connection: 
+      - Keep-Alive
+      content-type: 
+      - text/html; charset=UTF-8
+      date: 
+      - Thu, 25 Feb 2010 07:53:51 GMT
+      server: 
+      - Apache/2.2.3 (CentOS)
+      content-length: 
+      - "438"
+      age: 
+      - "9260"
+      accept-ranges: 
+      - bytes
+    :body: "var1: <%= var1 %>; var2: <%= var2 %>; var3: <%= var3 %>"
+    :http_version: "1.1"