vcr 0.4.1 → 1.0.0

data/spec/config_spec.rb

@@ -1,49 +0,0 @@
-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 'always has a hash, even if it is set to nil' do
-      VCR::Config.default_cassette_options = nil
-      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/cucumber_tags_spec.rb

@@ -1,71 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe VCR::CucumberTags do
-  before(:each) do
-    @args =   { :before => [], :after => [] }
-    @blocks = { :before => [], :after => [] }
-  end
-
-  def Before(*args, &block)
-    @args[:before]   << args
-    @blocks[:before] << block
-  end
-
-  def After(*args, &block)
-    @args[:after]   << args
-    @blocks[:after] << block
-  end
-
-  describe '#tag' do
-    [:before, :after].each do |hook|
-      it "sets up a cucumber #{hook} hook for the given tag that creates a new cassette" do
-        VCR.cucumber_tags { |t| t.tag 'tag_test' }
-
-        @args[hook].should == [['@tag_test']]
-
-        if hook == :before
-          VCR.should_receive(:insert_cassette).with('cucumber_tags/tag_test', {})
-        else
-          VCR.should_receive(:eject_cassette)
-        end
-        @blocks[hook].should have(1).block
-        @blocks[hook].first.call
-      end
-
-      it "sets up separate hooks for each tag, passing the given options to each cassette" do
-        VCR.cucumber_tags { |t| t.tag 'tag_test1', 'tag_test2', :record => :none }
-        @args[hook].should == [['@tag_test1'], ['@tag_test2']]
-
-        if hook == :before
-          VCR.should_receive(:insert_cassette).with('cucumber_tags/tag_test1', { :record => :none }).once
-          VCR.should_receive(:insert_cassette).with('cucumber_tags/tag_test2', { :record => :none }).once
-        else
-          VCR.should_receive(:eject_cassette).twice
-        end
-        @blocks[hook].should have(2).blocks
-        @blocks[hook].each { |b| b.call }
-      end
-
-      it "works with tags that start with an @" do
-        VCR.cucumber_tags { |t| t.tag '@tag_test' }
-        @args[hook].should == [['@tag_test']]
-
-        if hook == :before
-          VCR.should_receive(:insert_cassette).with('cucumber_tags/tag_test', {})
-        else
-          VCR.should_receive(:eject_cassette)
-        end
-        @blocks[hook].should have(1).block
-        @blocks[hook].first.call
-      end
-    end
-  end
-
-  describe '.tags' do
-    it 'returns the list of cucumber tags' do
-      VCR.cucumber_tags { |t| t.tag 'tag1' }
-      VCR.cucumber_tags { |t| t.tags 'tag7', 'tag12' }
-      VCR::CucumberTags.tags[-3, 3].should == %w(@tag1 @tag7 @tag12)
-    end
-  end
-end

data/spec/deprecations_spec.rb

@@ -1,67 +0,0 @@
-require 'spec_helper'
-
-describe 'Deprecations' do
-  describe VCR do
-    subject { VCR }
-    deprecated :create_cassette!,  :insert_cassette, "WARNING: VCR.create_cassette! is deprecated.  Instead, use: VCR.insert_cassette."
-    deprecated :destroy_cassette!, :eject_cassette,  "WARNING: VCR.destroy_cassette! is deprecated.  Instead, use: VCR.eject_cassette."
-    deprecated :with_cassette,     :use_cassette,    "WARNING: VCR.with_cassette is deprecated.  Instead, use: VCR.use_cassette."
-  end
-
-  describe VCR::Cassette do
-    disable_warnings
-    subject { VCR::Cassette.new('cassette name') }
-    deprecated :destroy!,   :eject, "WARNING: VCR::Cassette#destroy! is deprecated.  Instead, use: VCR::Cassette#eject."
-    deprecated :cache_file, :file,  "WARNING: VCR::Cassette#cache_file is deprecated.  Instead, use: VCR::Cassette#file."
-
-    it 'delegates the :unregistered record option to :new_episodes' do
-      cassette = VCR::Cassette.new('cassette name', :record => :unregistered)
-      cassette.record_mode.should == :new_episodes
-    end
-
-    it "prints a warning: WARNING: VCR's :unregistered record mode is deprecated.  Instead, use: :new_episodes." do
-      Kernel.should_receive(:warn).with("WARNING: VCR's :unregistered record mode is deprecated.  Instead, use: :new_episodes.")
-      VCR::Cassette.new('cassette name', :record => :unregistered)
-    end
-  end
-
-  describe VCR::Config do
-    disable_warnings
-    subject { VCR::Config }
-    deprecated :cache_dir,  :cassette_library_dir,  "WARNING: VCR::Config.cache_dir is deprecated.  Instead, use: VCR::Config.cassette_library_dir."
-
-    it 'delegates #cache_dir= to #cassette_library_dir=' do
-      subject.should_receive(:cassette_library_dir=).with(:value)
-      subject.cache_dir = :value
-    end
-
-    it "prints a warning: WARNING: VCR::Config.cache_dir= is deprecated.  Instead, use: VCR::Config.cassette_library_dir=." do
-      subject.stub!(:cassette_library_dir=)
-      subject.should_receive(:warn).with("WARNING: VCR::Config.cache_dir= is deprecated.  Instead, use: VCR::Config.cassette_library_dir=.")
-      subject.cache_dir = :value
-    end
-
-    describe '#default_cassette_record_mode=' do
-      it 'sets the default_cassette_options[:record] option' do
-        VCR::Cassette::VALID_RECORD_MODES.each do |mode|
-          VCR::Config.default_cassette_options = nil
-          VCR::Config.default_cassette_record_mode = mode
-          VCR::Config.default_cassette_options[:record].should == mode
-        end
-      end
-
-      it 'merges the :record option with the existing default_cassette_record options' do
-        VCR::Config.default_cassette_options = { :an => :option }
-        VCR::Config.default_cassette_record_mode = :all
-        VCR::Config.default_cassette_options.should == { :an => :option, :record => :all }
-      end
-
-      it 'warns the user that it is deprecated' do
-        VCR::Cassette::VALID_RECORD_MODES.each do |mode|
-          VCR::Config.should_receive(:warn).with(%Q{WARNING: #default_cassette_record_mode is deprecated.  Instead, use: "default_cassette_options = { :record => :#{mode.to_s} }"})
-          VCR::Config.default_cassette_record_mode = mode
-        end
-      end
-    end
-  end
-end

data/spec/extensions/net_http_response_spec.rb

@@ -1,86 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe "Net::HTTP Response extensions" do
-  context 'extending an already read response' do
-    # disable VCR for this spec...
-    before(:each) { VCR.insert_cassette('response_extension', :allow_real_http => lambda { |uri| true }) }
-    after(:each)  { VCR.eject_cassette }
-
-    def self.it_allows_the_body_to_be_read_again
-      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 block' do
-      subject do
-        http = Net::HTTP.new('example.com', 80)
-        response = http.request_get('/') { |res| res.read_body { |s| } }
-        response.extend VCR::Net::HTTPResponse
-        response
-      end
-
-      it_allows_the_body_to_be_read_again
-    end
-
-    context 'when the body has already been read using #read_body and a dest string' do
-      subject do
-        http = Net::HTTP.new('example.com', 80)
-        dest = ''
-        response = http.request_get('/') { |res| res.read_body(dest) }
-        response.extend VCR::Net::HTTPResponse
-        response
-      end
-
-      it_allows_the_body_to_be_read_again
-    end
-
-    context 'when the body has already been read using #body' do
-      subject do
-        http = Net::HTTP.new('example.com', 80)
-        response = http.request_get('/')
-        response.body
-        response.extend VCR::Net::HTTPResponse
-        response
-      end
-
-      it_allows_the_body_to_be_read_again
-    end
-  end
-end

data/spec/extensions/net_http_spec.rb

@@ -1,72 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe "Net::HTTP Extensions" do
-  before(:each) do
-    VCR.stub!(:current_cassette).and_return(@current_cassette = mock)
-    @uri = URI.parse('http://example.com')
-  end
-
-  it 'works when there is no current cassette' do
-    VCR.stub!(:current_cassette).and_return(nil)
-    lambda { Net::HTTP.get(@uri) }.should_not raise_error
-  end
-
-  context 'when current_cassette.allow_real_http_requests_to? returns false' do
-    before(:each) 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 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 #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 #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 #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 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
-  end
-
-  context 'when current_cassette.allow_real_http_requests_to? returns true' do
-    before(:each) do
-      @current_cassette.should_receive(:allow_real_http_requests_to?).with(@uri).and_return(true)
-    end
-
-    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 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
-end

data/spec/extensions/net_read_adapter_spec.rb

@@ -1,10 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe 'Net::ReadAdapter extensions' do
-  it 'delegates yaml serialization to the body string' do
-    adapter = Net::ReadAdapter.new(proc { |s| })
-    adapter << 'some text'
-    adapter << ' and some more text'
-    adapter.to_yaml.should == 'some text and some more text'.to_yaml
-  end
-end

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

@@ -1,29 +0,0 @@
---- 
-- !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.8.6/cassette_spec/example.yml

@@ -1,110 +0,0 @@
---- 
-- !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: 
-      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
-    body: |
-      <HTML>
-      <HEAD>
-        <TITLE>Example Web Page</TITLE>
-      </HEAD> 
-      <body>  
-      <p>You have reached this web page by typing &quot;example.com&quot;,
-      &quot;example.net&quot;,
-        or &quot;example.org&quot; into your web browser.</p>
-      <p>These domain names are reserved for use in documentation and are not available 
-        for registration. See <a href="http://www.rfc-editor.org/rfc/rfc2606.txt">RFC 
-        2606</a>, Section 3.</p>
-      </BODY>
-      </HTML>
-
-    http_version: "1.1"
-- !ruby/struct:VCR::HTTPInteraction 
-  request: !ruby/struct:VCR::Request 
-    method: :get
-    uri: http://example.com:80/foo
-    body: 
-    headers: 
-  response: !ruby/struct:VCR::Response 
-    status: !ruby/struct:VCR::ResponseStatus 
-      code: 404
-      message: Not Found
-    headers: 
-      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"
-    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>
-
-    http_version: "1.1"
-- !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: 
-      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
-    body: Another example.com response
-    http_version: "1.1"