vcr 1.2.0 → 1.3.0

data/spec/http_stubbing_adapters/typhoeus_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe VCR::HttpStubbingAdapters::Typhoeus do
+  without_monkey_patches :vcr
+
+  before(:each) do
+    ::Typhoeus::Hydra.stubs = []
+    ::Typhoeus::Hydra.allow_net_connect = true
+  end
+
+  it_behaves_like 'an http stubbing adapter', ['typhoeus'], [:method, :uri, :host, :path, :body, :headers]
+
+  it_performs('version checking',
+    :valid    => %w[ 0.2.0 0.2.99 ],
+    :too_low  => %w[ 0.1.0 0.1.31 ],
+    :too_high => %w[ 0.3.0 1.0.0 ]
+  ) do
+    disable_warnings
+    before(:each) { @orig_version = Typhoeus::VERSION }
+    after(:each)  { Typhoeus::VERSION = @orig_version }
+
+    # Cannot be regular method def as that raises a "dynamic constant assignment" error
+    define_method :stub_version do |version|
+      Typhoeus::VERSION = version
+    end
+  end
+end unless RUBY_PLATFORM == 'java'
+

data/spec/http_stubbing_adapters/webmock_spec.rb

@@ -3,35 +3,17 @@ require 'spec_helper'
 describe VCR::HttpStubbingAdapters::WebMock do
   without_monkey_patches :vcr
 
-  it_should_behave_like 'an http stubbing adapter',
+  it_behaves_like 'an http stubbing adapter',
     %w[net/http patron httpclient em-http-request curb],
     [:method, :uri, :host, :path, :body, :headers]
 
-  describe '#check_version!' do
-    before(:each) { WebMock.should respond_to(:version) }
-
-    %w( 0.9.9 0.9.10 0.1.30 1.0.30 1.2.9 1.3.9 ).each do |version|
-      it "raises an error when WebMock's version is #{version}" do
-        WebMock.stub!(:version).and_return(version)
-        described_class.should_not_receive(:warn)
-        expect { described_class.check_version! }.to raise_error(/You are using WebMock #{version}.  VCR requires version .* or greater/)
-      end
-    end
-
-    %w( 1.4.0 1.4.10 1.4.99 ).each do |version|
-      it "does nothing when WebMock's version is #{version}" do
-        WebMock.stub!(:version).and_return(version)
-        described_class.should_not_receive(:warn)
-        expect { described_class.check_version! }.to_not raise_error
-      end
-    end
-
-    %w( 1.5.0 1.10.0 2.0.0 ).each do |version|
-      it "does nothing when WebMock's version is #{version}" do
-        WebMock.stub!(:version).and_return(version)
-        described_class.should_receive(:warn).with(/VCR is known to work with WebMock ~> .*\./)
-        expect { described_class.check_version! }.to_not raise_error
-      end
+  it_performs('version checking',
+    :valid    => %w[ 1.4.0 1.4.99 1.5.0 1.5.99 ],
+    :too_low  => %w[ 0.9.9 0.9.10 0.1.30 1.0.30 1.2.9 1.3.9 ],
+    :too_high => %w[ 1.6.0 1.10.0 2.0.0 ]
+  ) do
+    def stub_version(version)
+      WebMock.stub(:version).and_return(version)
     end
   end
 end

data/spec/internet_connection_spec.rb

@@ -3,17 +3,35 @@ require 'spec_helper'
 describe VCR::InternetConnection do
   describe '.available?' do
     before(:each) do
-      described_class.instance_variable_set(:@available, nil)
+      described_class.send(:remove_instance_variable, :@available) if described_class.instance_variable_defined?(:@available)
     end
 
-    it 'returns true when pinging example.com succeeds' do
-      Ping.stub(:pingecho).with("example.com", anything, anything).and_return(true)
-      described_class.available?.should be_true
+    def stub_pingecho_with(value)
+      Ping.stub(:pingecho).with("example.com", anything, anything).and_return(value)
     end
 
-    it 'returns false when pinging example.com fails' do
-      Ping.stub(:pingecho).with("example.com", anything, anything).and_return(false)
-      described_class.available?.should be_false
+    context 'when pinging example.com succeeds' do
+      it 'returns true' do
+        stub_pingecho_with(true)
+        described_class.should be_available
+      end
+
+      it 'memoizes the value so no extra pings are made' do
+        Ping.should_receive(:pingecho).once.and_return(true)
+        3.times { described_class.available? }
+      end
+    end
+
+    context 'when pinging example.com fails' do
+      it 'returns false' do
+        stub_pingecho_with(false)
+        described_class.should_not be_available
+      end
+
+      it 'memoizes the value so no extra pings are made' do
+        Ping.should_receive(:pingecho).once.and_return(false)
+        3.times { described_class.available? }
+      end
     end
   end
 end

data/spec/spec_helper.rb

@@ -25,7 +25,7 @@ RSpec.configure do |config|
 
   config.before(:each) do
     VCR::Config.default_cassette_options = { :record => :new_episodes }
-    VCR::Config.http_stubbing_library = :fakeweb
+    VCR::Config.stub_with :fakeweb
 
     WebMock.allow_net_connect!
     WebMock.reset_webmock
@@ -36,5 +36,7 @@ RSpec.configure do |config|
 
   config.filter_run :focus => true
   config.run_all_when_everything_filtered = true
+
+  config.alias_it_should_behave_like_to :it_performs, 'it performs'
 end
 

data/spec/structs_spec.rb

@@ -32,6 +32,28 @@ describe VCR::Request do
     end
   end
 
+  describe 'uri normalization' do
+    def request(uri)
+      VCR::Request.new(:get, uri, '', {})
+    end
+
+    it 'adds port 80 to an http URI that lacks a port' do
+      request('http://example.com/foo').uri.should == 'http://example.com:80/foo'
+    end
+
+    it 'keeps the existing port for an http URI' do
+      request('http://example.com:8000/foo').uri.should == 'http://example.com:8000/foo'
+    end
+
+    it 'adds port 443 to an https URI that lacks a port' do
+      request('https://example.com/foo').uri.should == 'https://example.com:443/foo'
+    end
+
+    it 'keeps the existing port for an https URI' do
+      request('https://example.com:8000/foo').uri.should == 'https://example.com:8000/foo'
+    end
+  end
+
   describe '.from_net_http_request' do
     let(:net_http) { YAML.load(File.read(File.dirname(__FILE__) + "/fixtures/#{YAML_SERIALIZATION_VERSION}/example_net_http.yml")) }
     let(:request)  { YAML.load(File.read(File.dirname(__FILE__) + "/fixtures/#{YAML_SERIALIZATION_VERSION}/example_net_http_request.yml")) }
@@ -53,10 +75,11 @@ describe VCR::Request do
     end
   end
 
-  def with_headers(headers)
-    described_class.new(:get, 'http://example.com/', nil, headers)
+  it_behaves_like 'a header normalizer' do
+    def with_headers(headers)
+      described_class.new(:get, 'http://example.com/', nil, headers)
+    end
   end
-  it_should_behave_like 'a header normalizer'
 end
 
 describe VCR::ResponseStatus do
@@ -96,10 +119,11 @@ describe VCR::Response do
     end
   end
 
-  def with_headers(headers)
-    described_class.new(:status, headers, nil, '1.1')
+  it_behaves_like 'a header normalizer' do
+    def with_headers(headers)
+      described_class.new(:status, headers, nil, '1.1')
+    end
   end
-  it_should_behave_like 'a header normalizer'
 
   it "ensures the body is serialized to yaml as a raw string" do
     body = "My String"

data/spec/support/http_library_adapters.rb

@@ -96,10 +96,26 @@ HTTP_LIBRARY_ADAPTERS['curb'] = Module.new do
   end
 end
 
+HTTP_LIBRARY_ADAPTERS['typhoeus'] = Module.new do
+  def self.http_library_name; "Typhoeus"; end
+
+  def get_body_string(response)
+    response.body
+  end
+
+  def get_header(header_key, response)
+    response.headers_hash[header_key]
+  end
+
+  def make_http_request(method, url, body = nil, headers = {})
+    Typhoeus::Request.send(method, url, :body => body, :headers => headers)
+  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)
+  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
 
@@ -135,7 +151,7 @@ module HttpLibrarySpecs
                 end
               end
 
-              it 'raises an error for another method' do
+              it "raises an error for a request with a different #{attribute}" do
                 expect { make_http_request(invalid) }.to raise_error(NET_CONNECT_NOT_ALLOWED_ERROR)
               end
             else
@@ -192,11 +208,12 @@ module HttpLibrarySpecs
 
           it 'records new http requests' do
             VCR.should_receive(:record_http_interaction) do |interaction|
-              URI.parse(interaction.request.uri).to_s.should == URI.parse('http://example.com/foo').to_s
+              interaction.request.uri.should == 'http://example.com:80/foo'
               interaction.request.method.should == :get
               interaction.response.status.code.should == 404
               interaction.response.status.message.should == 'Not Found'
               interaction.response.body.should =~ /The requested URL \/foo was not found/
+              interaction.response.headers['content-type'].should == ["text/html; charset=iso-8859-1"]
             end
 
             make_http_request(:get, 'http://example.com/foo')
@@ -214,6 +231,11 @@ module HttpLibrarySpecs
         subject.request_stubbed?(VCR::Request.new(method, url), [:method, :uri]).should == expected
       end
 
+      it "returns false from #http_connections_allowed? when http_connections_allowed is set to nil" do
+        subject.http_connections_allowed = nil
+        subject.http_connections_allowed?.should == false
+      end
+
       [true, false].each do |http_allowed|
         context "when #http_connections_allowed is set to #{http_allowed}" do
           before(:each) { subject.http_connections_allowed = http_allowed }
@@ -257,14 +279,16 @@ module HttpLibrarySpecs
               subject.stub_requests(@recorded_interactions, VCR::RequestMatcher::DEFAULT_MATCH_ATTRIBUTES)
             end
 
-            it 'returns true from #request_stubbed? for the requests that are stubbed' do
-              test_request_stubbed(:post, 'http://example.com', true)
-              test_request_stubbed(:get, 'http://example.com/foo', true)
-            end
+            if other.include?(:needs_net_http_extension)
+              it 'returns true from #request_stubbed? for the requests that are stubbed' do
+                test_request_stubbed(:post, 'http://example.com', true)
+                test_request_stubbed(:get, 'http://example.com/foo', true)
+              end
 
-            it 'returns false from #request_stubbed? for requests that are not stubbed' do
-              test_request_stubbed(:post, 'http://example.com/foo', false)
-              test_request_stubbed(:get, 'http://google.com', false)
+              it 'returns false from #request_stubbed? for requests that are not stubbed' do
+                test_request_stubbed(:post, 'http://example.com/foo', false)
+                test_request_stubbed(:get, 'http://google.com', false)
+              end
             end
 
             it 'gets the stubbed responses when multiple post requests are made to http://example.com, and does not record them' do
@@ -275,7 +299,16 @@ module HttpLibrarySpecs
 
             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 with path=foo'
+              get_body_string(make_http_request(:get, 'http://example.com/foo')).should == 'example.com get response 1 with path=foo'
+            end
+
+            it 'rotates through multiple responses for the same request' do
+              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 2 with path=foo'
+
+              # 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
 
             it "correctly handles stubbing multiple values for the same header" do
@@ -287,10 +320,12 @@ module HttpLibrarySpecs
 
               test_real_http_request(http_allowed)
 
-              it 'returns false from #request_stubbed?' do
-                test_request_stubbed(:get, 'http://example.com/foo', false)
-                test_request_stubbed(:post, 'http://example.com', false)
-                test_request_stubbed(:get, 'http://google.com', false)
+              if other.include?(:needs_net_http_extension)
+                it 'returns false from #request_stubbed?' do
+                  test_request_stubbed(:get, 'http://example.com/foo', false)
+                  test_request_stubbed(:post, 'http://example.com', false)
+                  test_request_stubbed(:get, 'http://google.com', false)
+                end
               end
             end
           end

data/spec/support/http_stubbing_adapter.rb

@@ -1,20 +1,22 @@
-shared_examples_for "an http stubbing adapter" do |supported_http_libraries, supported_request_match_attributes|
+shared_examples_for "an http stubbing adapter" do |supported_http_libraries, supported_request_match_attributes, *other|
   extend HttpLibrarySpecs
   before(:each) { VCR.stub!(:http_stubbing_adapter).and_return(subject) }
   subject { described_class }
 
-  describe '#request_uri' do
-    it 'returns the uri for the given http request' do
-      net_http = Net::HTTP.new('example.com', 80)
-      request = Net::HTTP::Get.new('/foo/bar')
-      subject.request_uri(net_http, request).should == 'http://example.com:80/foo/bar'
-    end
+  if other.include?(:needs_net_http_extension)
+    describe '#request_uri' do
+      it 'returns the uri for the given http request' do
+        net_http = Net::HTTP.new('example.com', 80)
+        request = Net::HTTP::Get.new('/foo/bar')
+        subject.request_uri(net_http, request).should == 'http://example.com:80/foo/bar'
+      end
 
-    it 'handles basic auth' do
-      net_http = Net::HTTP.new('example.com',80)
-      request = Net::HTTP::Get.new('/auth.txt')
-      request.basic_auth 'user', 'pass'
-      subject.request_uri(net_http, request).should == 'http://user:pass@example.com:80/auth.txt'
+      it 'handles basic auth' do
+        net_http = Net::HTTP.new('example.com',80)
+        request = Net::HTTP::Get.new('/auth.txt')
+        request.basic_auth 'user', 'pass'
+        subject.request_uri(net_http, request).should == 'http://user:pass@example.com:80/auth.txt'
+      end
     end
   end
 
@@ -25,76 +27,83 @@ shared_examples_for "an http stubbing adapter" do |supported_http_libraries, sup
         subject.ignore_localhost?.should == val
       end
     end
+
+    it "returns false when ignore_localhost is set to nil" do
+      subject.ignore_localhost = nil
+      subject.ignore_localhost?.should == false
+    end
   end
 
-  describe '#request_stubbed? using specific match_attributes' do
-    let(:interactions) { YAML.load(File.read(File.join(File.dirname(__FILE__), '..', 'fixtures', YAML_SERIALIZATION_VERSION, 'match_requests_on.yml'))) }
+  if other.include?(:needs_net_http_extension)
+    describe '#request_stubbed? using specific match_attributes' do
+      let(:interactions) { YAML.load(File.read(File.join(File.dirname(__FILE__), '..', 'fixtures', YAML_SERIALIZATION_VERSION, 'match_requests_on.yml'))) }
 
-    @supported_request_match_attributes = supported_request_match_attributes
-    def self.matching_on(attribute, valid1, valid2, invalid, &block)
-      supported_request_match_attributes = @supported_request_match_attributes
+      @supported_request_match_attributes = supported_request_match_attributes
+      def self.matching_on(attribute, valid1, valid2, invalid, &block)
+        supported_request_match_attributes = @supported_request_match_attributes
 
-      describe ":#{attribute}" do
-        if supported_request_match_attributes.include?(attribute)
-          before(:each) { subject.stub_requests(interactions, [attribute]) }
-          module_eval(&block)
+        describe ":#{attribute}" do
+          if supported_request_match_attributes.include?(attribute)
+            before(:each) { subject.stub_requests(interactions, [attribute]) }
+            module_eval(&block)
 
-          [valid1, valid2].each do |val|
-            it "returns true for a #{val.inspect} request" do
-              subject.request_stubbed?(request(val), [attribute]).should be_true
+            [valid1, valid2].each do |val|
+              it "returns true for a #{val.inspect} request" do
+                subject.request_stubbed?(request(val), [attribute]).should == true
+              end
             end
-          end
 
-          it "returns false for another #{attribute}"  do
-            subject.request_stubbed?(request(invalid), [attribute]).should be_false
-          end
-        else
-          it 'raises an error indicating matching requests on this attribute is not supported' do
-            expect { subject.request_stubbed?(VCR::Request.new, [attribute]) }.to raise_error(/does not support matching requests on #{attribute}/)
+            it "returns false for another #{attribute}"  do
+              subject.request_stubbed?(request(invalid), [attribute]).should == false
+            end
+          else
+            it 'raises an error indicating matching requests on this attribute is not supported' do
+              expect { subject.request_stubbed?(VCR::Request.new, [attribute]) }.to raise_error(/does not support matching requests on #{attribute}/)
+            end
           end
         end
       end
-    end
 
-    matching_on :method, :get, :post, :put do
-      def request(http_method)
-        VCR::Request.new(http_method, 'http://some-wrong-domain.com/', nil, {})
+      matching_on :method, :get, :post, :put do
+        def request(http_method)
+          VCR::Request.new(http_method, 'http://some-wrong-domain.com/', nil, {})
+        end
       end
-    end
 
-    matching_on :host, 'example1.com', 'example2.com', 'example3.com' do
-      def request(host)
-        VCR::Request.new(:get, "http://#{host}/some/wrong/path", nil, {})
+      matching_on :host, 'example1.com', 'example2.com', 'example3.com' do
+        def request(host)
+          VCR::Request.new(:get, "http://#{host}/some/wrong/path", nil, {})
+        end
       end
-    end
 
-    matching_on :uri, 'http://example.com/uri1', 'http://example.com/uri2', 'http://example.com/uri3' do
-      def request(uri)
-        VCR::Request.new(:get, uri, nil, {})
+      matching_on :uri, 'http://example.com/uri1', 'http://example.com/uri2', 'http://example.com/uri3' do
+        def request(uri)
+          VCR::Request.new(:get, uri, nil, {})
+        end
       end
-    end
 
-    matching_on :path, '/path1', '/path2', '/path3' do
-      def request(path)
-        VCR::Request.new(:get, "http://example.com#{path}", nil, {})
+      matching_on :path, '/path1', '/path2', '/path3' do
+        def request(path)
+          VCR::Request.new(:get, "http://example.com#{path}", nil, {})
+        end
       end
-    end
 
-    matching_on :body, 'param=val1', 'param=val2', 'param=val3' do
-      def request(body)
-        VCR::Request.new(:put, "http://wrong-domain.com/wrong/path", body, {})
+      matching_on :body, 'param=val1', 'param=val2', 'param=val3' do
+        def request(body)
+          VCR::Request.new(:put, "http://wrong-domain.com/wrong/path", body, {})
+        end
       end
-    end
 
-    matching_on :headers, { 'X-HTTP-HEADER1' => 'val1' }, { 'X-HTTP-HEADER1' => 'val2' }, { 'X-HTTP-HEADER1' => 'val3' } do
-      def request(headers)
-        VCR::Request.new(:get, "http://wrong-domain.com/wrong/path", nil, headers)
+      matching_on :headers, { 'X-HTTP-HEADER1' => 'val1' }, { 'X-HTTP-HEADER1' => 'val2' }, { 'X-HTTP-HEADER1' => 'val3' } do
+        def request(headers)
+          VCR::Request.new(:get, "http://wrong-domain.com/wrong/path", nil, headers)
+        end
       end
     end
   end
 
   supported_http_libraries.each do |library|
-    test_http_library library, supported_request_match_attributes
+    test_http_library library, supported_request_match_attributes, *other
   end
 end