vcr 1.1.0 → 1.1.1

data/spec/spec_helper.rb

@@ -0,0 +1,40 @@
+require 'rubygems'
+require 'bundler'
+Bundler.setup
+
+require 'patron' unless RUBY_PLATFORM =~ /java/
+require 'httpclient'
+require 'em-http-request' unless RUBY_PLATFORM =~ /java/
+require 'vcr'
+require 'vcr/http_stubbing_adapters/fakeweb'
+require 'vcr/http_stubbing_adapters/webmock'
+require 'rspec'
+
+# Ruby 1.9.1 has a different yaml serialization format.
+YAML_SERIALIZATION_VERSION = RUBY_VERSION == '1.9.1' ? '1.9.1' : 'not_1.9.1'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir[File.expand_path(File.join(File.dirname(__FILE__),'support','**','*.rb'))].each {|f| require f}
+
+RSpec.configure do |config|
+  config.extend TempCassetteLibraryDir
+  config.extend DisableWarnings
+
+  config.color_enabled = true
+  config.debug = RUBY_PLATFORM != 'java'
+
+  config.before(:each) do
+    VCR::Config.default_cassette_options = { :record => :new_episodes }
+    VCR::Config.http_stubbing_library = :fakeweb
+
+    WebMock.allow_net_connect!
+    WebMock.reset_webmock
+
+    FakeWeb.allow_net_connect = true
+    FakeWeb.clean_registry
+  end
+
+  config.filter_run :focus => true
+  config.run_all_when_everything_filtered = true
+end

data/spec/structs_spec.rb

@@ -0,0 +1,121 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+shared_examples_for "a header normalizer" do
+  let(:instance) do
+    with_headers('Some_Header' => 'value1', 'aNother' => ['a', 'b'], 'third' => [], 'FOURTH' => nil)
+  end
+
+  it 'normalizes the hash to lower case keys and arrays of values' do
+    instance.headers.should == {
+      'some_header' => ['value1'],
+      'another'     => ['a', 'b'],
+      'third'       => [],
+      'fourth'      => []
+    }
+  end
+
+  it 'set nil header to an empty hash' do
+    with_headers(nil).headers.should == {}
+  end
+end
+
+describe VCR::Request do
+  describe '#matcher' do
+    it 'returns a matcher with the given request' do
+      req = VCR::Request.new
+      req.matcher([:uri]).request.should == req
+    end
+
+    it 'returns a matcher with the given match_attributes' do
+      req = VCR::Request.new
+      req.matcher([:uri, :headers]).match_attributes.to_a.should =~ [:uri, :headers]
+    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")) }
+    subject { described_class.from_net_http_request(net_http, request) }
+
+    before(:each) do
+      VCR.http_stubbing_adapter.should respond_to(:request_uri)
+      VCR.http_stubbing_adapter.stub!(:request_uri)
+    end
+
+    it            { should be_instance_of(VCR::Request) }
+    its(:method)  { should == :post  }
+    its(:body)    { should == 'id=7'  }
+    its(:headers) { should == { "accept" => ["*/*"], "content-type" => ["application/x-www-form-urlencoded"] } }
+
+    it 'sets the uri using the http_stubbing_adapter.request_uri' do
+      VCR.http_stubbing_adapter.should_receive(:request_uri).with(net_http, request).and_return('foo/bar')
+      subject.uri.should == 'foo/bar'
+    end
+  end
+
+  def with_headers(headers)
+    described_class.new(:get, 'http://example.com/', nil, headers)
+  end
+  it_should_behave_like 'a header normalizer'
+end
+
+describe VCR::ResponseStatus do
+  describe '.from_net_http_response' do
+    let(:response) { YAML.load(File.read(File.dirname(__FILE__) + "/fixtures/#{YAML_SERIALIZATION_VERSION}/example_net_http_response.yml")) }
+    subject { described_class.from_net_http_response(response) }
+
+    it            { should be_instance_of(described_class) }
+    its(:code)    { should == 200 }
+    its(:message) { should == 'OK' }
+  end
+end
+
+describe VCR::Response do
+  describe '.from_net_http_response' do
+    let(:response) { YAML.load(File.read(File.dirname(__FILE__) + "/fixtures/#{YAML_SERIALIZATION_VERSION}/example_net_http_response.yml")) }
+    subject { described_class.from_net_http_response(response) }
+
+    it                 { should be_instance_of(described_class) }
+    its(:body)         { should == 'The response from example.com' }
+    its(:http_version) { should == '1.1' }
+    its(:headers)      { should == {
+      "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']
+    } }
+
+    it 'assigns the status using VCR::ResponseStatus.from_net_http_response' do
+      VCR::ResponseStatus.should respond_to(:from_net_http_response)
+      VCR::ResponseStatus.should_receive(:from_net_http_response).with(response).and_return(:the_status)
+      subject.status.should == :the_status
+    end
+  end
+
+  def with_headers(headers)
+    described_class.new(:status, headers, nil, '1.1')
+  end
+  it_should_behave_like 'a header normalizer'
+
+  it "ensures the body is serialized to yaml as a raw string" do
+    body = "My String"
+    body.instance_variable_set(:@foo, 7)
+    instance = described_class.new(:status, {}, body, :version)
+    instance.body.to_yaml.should == "My String".to_yaml
+  end
+end
+
+describe VCR::HTTPInteraction do
+  %w( uri method ).each do |attr|
+    it "delegates :#{attr} to the request signature" do
+      sig = mock('request signature')
+      sig.should_receive(attr).and_return(:the_value)
+      instance = described_class.new(sig, nil)
+      instance.send(attr).should == :the_value
+    end
+  end
+end

data/spec/support/disable_warnings.rb

@@ -0,0 +1,12 @@
+module DisableWarnings
+  def disable_warnings
+    before(:all) do
+      @orig_std_err = $stderr
+      $stderr = StringIO.new
+    end
+
+    after(:all) do
+      $stderr = @orig_std_err
+    end
+  end
+end

data/spec/support/http_library_adapters.rb

@@ -0,0 +1,272 @@
+HTTP_LIBRARY_ADAPTERS = {}
+
+HTTP_LIBRARY_ADAPTERS['net/http'] = Module.new do
+  def self.http_library_name; 'Net::HTTP'; end
+
+  def get_body_string(response); response.body; end
+
+  def get_header(header_key, response)
+    response.get_fields(header_key)
+  end
+
+  def make_http_request(method, url, body = nil, headers = {})
+    uri = URI.parse(url)
+    Net::HTTP.new(uri.host, uri.port).send_request(method.to_s.upcase, uri.path, body, headers)
+  end
+end
+
+HTTP_LIBRARY_ADAPTERS['patron'] = Module.new do
+  def self.http_library_name; 'Patron'; end
+
+  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 = {})
+    Patron::Session.new.request(method, url, headers, :data => body || '')
+  end
+end
+
+HTTP_LIBRARY_ADAPTERS['httpclient'] = Module.new do
+  def self.http_library_name; 'HTTP Client'; end
+
+  def get_body_string(response)
+    string = response.body.content
+    string.respond_to?(:read) ? string.read : string
+  end
+
+  def get_header(header_key, response)
+    response.header[header_key]
+  end
+
+  def make_http_request(method, url, body = nil, headers = {})
+    HTTPClient.new.request(method, url, nil, body, headers)
+  end
+end
+
+HTTP_LIBRARY_ADAPTERS['em-http-request'] = Module.new do
+  def self.http_library_name; 'EM HTTP Request'; end
+
+  def get_body_string(response)
+    response.response
+  end
+
+  def get_header(header_key, response)
+    response.response_header[header_key.upcase.gsub('-', '_')].split(', ')
+  end
+
+  def make_http_request(method, url, body = nil, headers = {})
+    http = nil
+    EventMachine.run do
+      http = EventMachine::HttpRequest.new(url).send(method, :body => body, :head => headers)
+      http.callback { EventMachine.stop }
+    end
+    http
+  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)
+    # patron and em-http-client cannot be installed on jruby
+    return if %w[patron em-http-request].include?(library) && RUBY_PLATFORM == 'java'
+
+    unless adapter_module = HTTP_LIBRARY_ADAPTERS[library]
+      raise ArgumentError.new("No http library adapter module could be found for #{library}")
+    end
+
+    describe "using #{adapter_module.http_library_name}" do
+      include adapter_module
+
+      # Necessary for ruby 1.9.2.  On 1.9.2 we get an error when we use super,
+      # so this gives us another alias we can use for the original method.
+      alias make_request make_http_request
+
+      describe '#stub_requests using specific match_attributes' do
+        before(:each) { subject.http_connections_allowed = false }
+        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, valid, invalid, &block)
+          supported_request_match_attributes = @supported_request_match_attributes
+
+          describe ":#{attribute}" do
+            let(:perform_stubbing) { subject.stub_requests(interactions, [attribute]) }
+
+            if supported_request_match_attributes.include?(attribute)
+              before(:each) { perform_stubbing }
+              module_eval(&block)
+
+              valid.each do |val, response|
+                it "returns the expected response for a #{val.inspect} request" do
+                  get_body_string(make_http_request(val)).should == response
+                end
+              end
+
+              it 'raises an error for another method' do
+                expect { make_http_request(invalid) }.to raise_error(NET_CONNECT_NOT_ALLOWED_ERROR)
+              end
+            else
+              it 'raises an error indicating matching requests on this attribute is not supported' do
+                expect { perform_stubbing }.to raise_error(/does not support matching requests on #{attribute}/)
+              end
+            end
+          end
+        end
+
+        matching_on :method, { :get => "get method response", :post => "post method response" }, :put do
+          def make_http_request(http_method)
+            make_request(http_method, 'http://some-wrong-domain.com/', nil, {})
+          end
+        end
+
+        matching_on :host, { 'example1.com' => 'example1.com host response', 'example2.com' => 'example2.com host response' }, 'example3.com' do
+          def make_http_request(host)
+            make_request(:get, "http://#{host}/some/wrong/path", nil, {})
+          end
+        end
+
+        matching_on :path, { '/path1' => 'path1 response', '/path2' => 'path2 response' }, '/path3' do
+          def make_http_request(path)
+            make_request(:get, "http://some.wrong.domain.com#{path}?p=q", nil, {})
+          end
+        end
+
+        matching_on :uri, { 'http://example.com/uri1' => 'uri1 response', 'http://example.com/uri2' => 'uri2 response' }, 'http://example.com/uri3' do
+          def make_http_request(uri)
+            make_request(:get, uri, nil, {})
+          end
+        end
+
+        matching_on :body, { 'param=val1' => 'val1 body response', 'param=val2' => 'val2 body response' }, 'param=val3' do
+          def make_http_request(body)
+            make_request(:put, "http://wrong-domain.com/wrong/path", body, {})
+          end
+        end
+
+        matching_on :headers, {{ 'X-HTTP-HEADER1' => 'val1' } => 'val1 header response', { 'X-HTTP-HEADER1' => 'val2' } => 'val2 header response' }, { 'X-HTTP-HEADER1' => 'val3' } do
+          def make_http_request(headers)
+            make_request(:get, "http://wrong-domain.com/wrong/path", nil, headers)
+          end
+        end
+      end
+
+      def self.test_real_http_request(http_allowed)
+        if http_allowed
+
+          it 'allows real http requests' do
+            get_body_string(make_http_request(:get, 'http://example.com/foo')).should =~ /The requested URL \/foo was not found/
+          end
+
+          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.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/
+            end
+
+            make_http_request(:get, 'http://example.com/foo')
+          end
+
+        else
+          it 'does not allow real HTTP requests or record them' do
+            VCR.should_receive(:record_http_interaction).never
+            lambda { make_http_request(:get, 'http://example.com/foo') }.should raise_error(NET_CONNECT_NOT_ALLOWED_ERROR)
+          end
+        end
+      end
+
+      def test_request_stubbed(method, url, expected)
+        subject.request_stubbed?(VCR::Request.new(method, url), [:method, :uri]).should == expected
+      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 }
+
+          it "returns #{http_allowed} for #http_connections_allowed?" do
+            subject.http_connections_allowed?.should == http_allowed
+          end
+
+          test_real_http_request(http_allowed)
+
+          unless http_allowed
+            describe '.ignore_localhost =' do
+              let(:localhost_response) { 'A localhost response!' }
+              let(:localhost_server)   { VCR::LocalhostServer::STATIC_SERVERS[localhost_response] }
+
+              VCR::LOCALHOST_ALIASES.each do |localhost_alias|
+                describe 'when set to true' do
+                  extend PendingOnHeroku
+                  before(:each) { subject.ignore_localhost = true }
+
+                  it "allows requests to #{localhost_alias}" do
+                    get_body_string(make_http_request(:get, "http://#{localhost_alias}:#{localhost_server.port}/")).should == localhost_response
+                  end
+                end
+
+                describe 'when set to false' do
+                  before(:each) { subject.ignore_localhost = false }
+
+                  it "does not allow requests to #{localhost_alias}" do
+                    expect { make_http_request(:get, "http://#{localhost_alias}:#{localhost_server.port}/") }.to raise_error(NET_CONNECT_NOT_ALLOWED_ERROR)
+                  end
+                end
+              end
+            end
+          end
+
+          context 'when some requests are stubbed, after setting a checkpoint' do
+            before(:each) do
+              subject.create_stubs_checkpoint(:my_checkpoint)
+              @recorded_interactions = YAML.load(File.read(File.join(File.dirname(__FILE__), '..', 'fixtures', YAML_SERIALIZATION_VERSION, 'fake_example.com_responses.yml')))
+              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
+
+            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
+
+            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 with path=foo'
+            end
+
+            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']
+            end
+
+            context 'when we restore our previous check point' do
+              before(:each) { subject.restore_stubs_checkpoint(:my_checkpoint) }
+
+              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)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end