vcr 1.1.0 → 1.1.1

data/spec/fixtures/not_1.9.1/match_requests_on.yml

@@ -0,0 +1,185 @@
+--- 
+- !ruby/struct:VCR::HTTPInteraction 
+  request: !ruby/struct:VCR::Request 
+    method: :post
+    uri: http://example.com:80/method
+    body: 
+    headers: 
+  response: !ruby/struct:VCR::Response 
+    status: !ruby/struct:VCR::ResponseStatus 
+      code: 200
+      message: OK
+    headers: 
+      etag: 
+      - "\"24ec5-1b6-4059a80bfd280\""
+    body: post method response
+    http_version: "1.1"
+- !ruby/struct:VCR::HTTPInteraction 
+  request: !ruby/struct:VCR::Request 
+    method: :get
+    uri: http://example.com:80/method
+    body: 
+    headers: 
+  response: !ruby/struct:VCR::Response 
+    status: !ruby/struct:VCR::ResponseStatus 
+      code: 200
+      message: OK
+    headers: 
+      etag: 
+      - "\"24ec5-1b6-4059a80bfd280\""
+    body: get method response
+    http_version: "1.1"
+- !ruby/struct:VCR::HTTPInteraction 
+  request: !ruby/struct:VCR::Request 
+    method: :post
+    uri: http://example1.com:80/host
+    body: 
+    headers: 
+  response: !ruby/struct:VCR::Response 
+    status: !ruby/struct:VCR::ResponseStatus 
+      code: 200
+      message: OK
+    headers: 
+      etag: 
+      - "\"24ec5-1b6-4059a80bfd280\""
+    body: example1.com host response
+    http_version: "1.1"
+- !ruby/struct:VCR::HTTPInteraction 
+  request: !ruby/struct:VCR::Request 
+    method: :post
+    uri: http://example2.com:80/host
+    body: 
+    headers: 
+  response: !ruby/struct:VCR::Response 
+    status: !ruby/struct:VCR::ResponseStatus 
+      code: 200
+      message: OK
+    headers: 
+      etag: 
+      - "\"24ec5-1b6-4059a80bfd280\""
+    body: example2.com host response
+    http_version: "1.1"
+- !ruby/struct:VCR::HTTPInteraction 
+  request: !ruby/struct:VCR::Request 
+    method: :post
+    uri: http://example.com:80/path1
+    body: 
+    headers: 
+  response: !ruby/struct:VCR::Response 
+    status: !ruby/struct:VCR::ResponseStatus 
+      code: 200
+      message: OK
+    headers: 
+      etag: 
+      - "\"24ec5-1b6-4059a80bfd280\""
+    body: path1 response
+    http_version: "1.1"
+- !ruby/struct:VCR::HTTPInteraction 
+  request: !ruby/struct:VCR::Request 
+    method: :post
+    uri: http://example.com:80/path2
+    body: 
+    headers: 
+  response: !ruby/struct:VCR::Response 
+    status: !ruby/struct:VCR::ResponseStatus 
+      code: 200
+      message: OK
+    headers: 
+      etag: 
+      - "\"24ec5-1b6-4059a80bfd280\""
+    body: path2 response
+    http_version: "1.1"
+- !ruby/struct:VCR::HTTPInteraction 
+  request: !ruby/struct:VCR::Request 
+    method: :post
+    uri: http://example.com:80/uri1
+    body: 
+    headers: 
+  response: !ruby/struct:VCR::Response 
+    status: !ruby/struct:VCR::ResponseStatus 
+      code: 200
+      message: OK
+    headers: 
+      etag: 
+      - "\"24ec5-1b6-4059a80bfd280\""
+    body: uri1 response
+    http_version: "1.1"
+- !ruby/struct:VCR::HTTPInteraction 
+  request: !ruby/struct:VCR::Request 
+    method: :post
+    uri: http://example.com:80/uri2
+    body: 
+    headers: 
+  response: !ruby/struct:VCR::Response 
+    status: !ruby/struct:VCR::ResponseStatus 
+      code: 200
+      message: OK
+    headers: 
+      etag: 
+      - "\"24ec5-1b6-4059a80bfd280\""
+    body: uri2 response
+    http_version: "1.1"
+- !ruby/struct:VCR::HTTPInteraction 
+  request: !ruby/struct:VCR::Request 
+    method: :post
+    uri: http://example.com:80/
+    body: param=val1
+    headers: 
+  response: !ruby/struct:VCR::Response 
+    status: !ruby/struct:VCR::ResponseStatus 
+      code: 200
+      message: OK
+    headers: 
+      etag: 
+      - "\"24ec5-1b6-4059a80bfd280\""
+    body: val1 body response
+    http_version: "1.1"
+- !ruby/struct:VCR::HTTPInteraction 
+  request: !ruby/struct:VCR::Request 
+    method: :post
+    uri: http://example.com:80/
+    body: param=val2
+    headers: 
+  response: !ruby/struct:VCR::Response 
+    status: !ruby/struct:VCR::ResponseStatus 
+      code: 200
+      message: OK
+    headers: 
+      etag: 
+      - "\"24ec5-1b6-4059a80bfd280\""
+    body: val2 body response
+    http_version: "1.1"
+- !ruby/struct:VCR::HTTPInteraction 
+  request: !ruby/struct:VCR::Request 
+    method: :post
+    uri: http://example.com:80/
+    body: 
+    headers: 
+      x-http-header1: 
+      - val1
+  response: !ruby/struct:VCR::Response 
+    status: !ruby/struct:VCR::ResponseStatus 
+      code: 200
+      message: OK
+    headers: 
+      etag: 
+      - "\"24ec5-1b6-4059a80bfd280\""
+    body: val1 header response
+    http_version: "1.1"
+- !ruby/struct:VCR::HTTPInteraction 
+  request: !ruby/struct:VCR::Request 
+    method: :post
+    uri: http://example.com:80/
+    body: 
+    headers: 
+      x-http-header1: 
+      - val2
+  response: !ruby/struct:VCR::Response 
+    status: !ruby/struct:VCR::ResponseStatus 
+      code: 200
+      message: OK
+    headers: 
+      etag: 
+      - "\"24ec5-1b6-4059a80bfd280\""
+    body: val2 header response
+    http_version: "1.1"

data/spec/http_stubbing_adapters/fakeweb_spec.rb

@@ -0,0 +1,35 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe VCR::HttpStubbingAdapters::FakeWeb do
+  it_should_behave_like 'an http stubbing adapter', ['net/http'], [:method, :uri, :host, :path]
+
+  describe '#check_version!' do
+    disable_warnings
+    before(:each) { @orig_version = FakeWeb::VERSION }
+    after(:each)  { FakeWeb::VERSION = @orig_version }
+
+    %w( 1.2.8 1.1.30 0.30.30 ).each do |version|
+      it "raises an error when FakeWeb's version is #{version}" do
+        FakeWeb::VERSION = version
+        described_class.should_not_receive(:warn)
+        expect { described_class.check_version! }.to raise_error(/You are using FakeWeb #{version}.  VCR requires version .* or greater/)
+      end
+    end
+
+    %w( 1.3.0 1.3.1 1.3.99 ).each do |version|
+      it "does nothing when FakeWeb's version is #{version}" do
+        FakeWeb::VERSION = version
+        described_class.should_not_receive(:warn)
+        expect { described_class.check_version! }.to_not raise_error
+      end
+    end
+
+    %w( 1.4.0 1.10.0 2.0.0 ).each do |version|
+      it "prints a warning when FakeWeb's version is #{version}" do
+        FakeWeb::VERSION = version
+        described_class.should_receive(:warn).with(/VCR is known to work with FakeWeb ~> .*\./)
+        expect { described_class.check_version! }.to_not raise_error
+      end
+    end
+  end
+end

data/spec/http_stubbing_adapters/webmock_spec.rb

@@ -0,0 +1,35 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe VCR::HttpStubbingAdapters::WebMock do
+  it_should_behave_like 'an http stubbing adapter',
+    %w[net/http patron httpclient em-http-request],
+    [: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.2 ).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.3.3 1.3.10 1.3.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.4.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
+    end
+  end
+end

data/spec/request_matcher_spec.rb

@@ -0,0 +1,194 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe VCR::RequestMatcher do
+  it 'raises an error when given invalid match attributes' do
+    expect {
+      VCR::RequestMatcher.new(VCR::Request.new, [:not, :valid, :options])
+    }.to raise_error(ArgumentError)
+  end
+
+  describe '#uri' do
+    def self.for_matcher(*attributes, &block)
+      context "for match_attributes = #{attributes.inspect}" do
+        subject { matcher = VCR::RequestMatcher.new(stub(:uri => uri), attributes).uri }
+        module_eval(&block)
+      end
+    end
+
+    let(:uri) { 'http://foo.example.com/path/to/something?param=value' }
+
+    for_matcher do
+      it("returns a regex that matches any URI") { should == /.*/ }
+    end
+
+    for_matcher :uri do
+      it("returns the exact uri") { should == uri }
+    end
+
+    for_matcher :host do
+      it("matches a basic URL for the same host") { should =~ 'http://foo.example.com/some/path' }
+      it("matches an https URL") { should =~ 'https://foo.example.com/some/path' }
+      it("ignores the case of the URL") { should =~ 'HTTP://FOO.EXAMPLE.COM/SOME/PATH' }
+      it("matches when the URL has the normal port") { should =~ 'http://foo.example.com:80/some/path' }
+      it("matches when the URL has another port") { should =~ 'http://foo.example.com:3750/some/path' }
+      it("matches when the URL has a username") { should =~ 'http://someone@foo.example.com/some/path' }
+      it("matches when the URL has a username and password") { should =~ 'http://admin:s3cr3t@foo.example.com/some/path' }
+
+      it("does not match when the host is wrong") { should_not =~ 'http://fof.example.com/path/to/something?param=value' }
+      it("does not match when the host includes some additional parts")  { should_not =~ 'http://foo.example.com.more.domain.parts/path/to/something?param=value' }
+    end
+
+    for_matcher :path do
+      it("matches a basic URL for the same path") { should =~ 'http://domain.tld/path/to/something?p=v&q=r' }
+      it("matches an https URL") { should =~ 'http://domain.tld/path/to/something?p=v&q=r' }
+      it("ignores the case of the URL") { should =~ 'HTTP://DOMAIN.TLD/PATH/TO/SOMETHING?P=V&Q=R' }
+      it("matches with a trailing slash") { should =~ 'http://domain.tld/path/to/something/' }
+      it("matches without a trailing slash") { should =~ 'http://domain.tld/path/to/something' }
+      it("matches when the URL has the normal port") { should =~ 'http://domain.tld:80/path/to/something' }
+      it("matches when the URL has another port") { should =~ 'http://domain.tld:3750/path/to/something' }
+      it("matches when the URL has a username") { should =~ 'http://someone@domain.tld/path/to/something' }
+      it("matches when the URL has a username and password") { should =~ 'http://admin:s3cr3t@domain.tld/path/to/something' }
+
+      it("does not match when the path is wrong") { should_not =~ 'http://foo.example.com/some/other/path?param=value' }
+      it("does not match when the path includes some additional parts") { should_not =~ 'http://foo.example.com/path/to/something/else?param=value' }
+    end
+
+    for_matcher :host, :path do
+      it("matches a basic URL for the same host and path") { should =~ 'http://foo.example.com/path/to/something?p=v' }
+      it("matches an https URL") { should =~ 'https://foo.example.com/path/to/something?p=v&q=r' }
+      it("ignores the case of the URL") { should =~ 'HTTP://FOO.EXAMPLE.COM/PATH/TO/SOMETHING?P=V&Q=R' }
+      it("matches with a trailing slash and some query params") { should =~ 'http://foo.example.com/path/to/something/?p=v&q=r' }
+      it("matches with a trailing slash and no query params") { should =~ 'http://foo.example.com/path/to/something/' }
+      it("matches without a trailing slash and some query params") { should =~ 'http://foo.example.com/path/to/something?p=v&q=r' }
+      it("matches without a trailing slash and no query params") { should =~ 'http://foo.example.com/path/to/something' }
+      it("matches when the URL has the normal port") { should =~ 'http://foo.example.com:80/path/to/something?p=v' }
+      it("matches when the URL has another port") { should =~ 'http://foo.example.com:3750/path/to/something?p=v' }
+      it("matches when the URL has a username") { should =~ 'http://someone@foo.example.com/path/to/something?p=v' }
+      it("matches when the URL has a username and password") { should =~ 'http://admin:s3r3t@foo.example.com/path/to/something?p=v' }
+
+      it("does not match when the host is wrong") { should_not =~ 'http://fof.example.com/path/to/something?p=v' }
+      it("does not match when the path is wrong") { should_not =~ 'http://foo.example.com/pth/to/something?p=v' }
+      it("does not match when the host includes some additional parts") { should_not =~ 'http://foo.example.com.and.more.parts/path/to/something?p=v' }
+      it("does not match when the path includes some additional parts") { should_not =~ 'http://foo.example.com/path/to/something/else?p=v' }
+    end
+
+    [[:uri, :host], [:uri, :path], [:uri, :host, :path]].each do |attributes|
+      for_matcher *attributes do
+        it "raises an appropriate error" do
+          expect { subject }.to raise_error(/match_attributes cannot include/)
+        end
+      end
+    end
+
+    it "returns the request's URI when it is a regex, regardless of the match attributes" do
+      [:uri, :host, :path].each do |attribute|
+        matcher = VCR::RequestMatcher.new(stub(:uri => /some regex/), [attribute])
+        matcher.uri.should == /some regex/
+      end
+    end
+  end
+
+  describe '#method' do
+    it 'returns the request method when the match attributes include :method' do
+      matcher = VCR::RequestMatcher.new(stub(:method => :get), [:method])
+      matcher.method.should == :get
+    end
+
+    it 'returns nil when the match attributes do not include :method' do
+      matcher = VCR::RequestMatcher.new(stub(:method => :get), [])
+      matcher.method.should be_nil
+    end
+  end
+
+  describe '#body' do
+    it 'returns the request body when the match attributes include :body' do
+      matcher = VCR::RequestMatcher.new(stub(:body => 'id=7'), [:body])
+      matcher.body.should == 'id=7'
+    end
+
+    it 'returns nil when the match attributes do not include :body' do
+      matcher = VCR::RequestMatcher.new(stub(:body => 'id=7'), [])
+      matcher.method.should be_nil
+    end
+  end
+
+  describe '#headers' do
+    it 'returns the request headers when the match attributes include :headers' do
+      matcher = VCR::RequestMatcher.new(stub(:headers => { 'key' => 'value' }), [:headers])
+      matcher.headers.should == { 'key' => 'value' }
+    end
+
+    it 'returns nil when the match attributes do not include :headers' do
+      matcher = VCR::RequestMatcher.new(stub(:headers => { 'key' => 'value' }), [])
+      matcher.headers.should be_nil
+    end
+  end
+
+  def matcher(*different_values)
+    match_attributes = [:method, :uri, :body, :headers]
+    if different_values.include?(:match_attributes)
+      match_attributes -= [:body]
+    end
+
+    request_object = different_values.include?(:request) ? 'request2' : 'request'
+    m = VCR::RequestMatcher.new(request_object, match_attributes)
+
+    %w( uri method body headers ).each do |attr|
+      m.should respond_to(attr)
+      m.stub!(attr).and_return(different_values.include?(attr.to_sym) ? attr.next : attr)
+    end
+
+    m
+  end
+
+  def matchers_varying_on(attribute)
+    return matcher, matcher(attribute)
+  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)
+      m1.hash.should == m2.hash
+    end
+
+    it 'returns the same code for two objects when the matchers are the same, but #match_attributes has its elements in a different order' do
+      m1, m2 = matcher, matcher
+      m1.match_attributes = [:method, :uri, :body, :headers]
+      m2.match_attributes = [:method, :body, :uri, :headers]
+      m1.hash.should == m2.hash
+    end
+
+    [:match_attributes, :method, :uri, :body, :headers].each do |different_attr|
+      it "returns different codes for two objects when ##{different_attr} is different, even when the request object is the same" do
+        m1, m2 = matchers_varying_on(different_attr)
+        m1.hash.should_not == m2.hash
+      end
+    end
+  end
+
+  [:eql?, :==].each do |equality_method|
+    describe "##{equality_method.to_s}" do
+      it 'returns true 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)
+        m1.send(equality_method, m2).should be_true
+        m2.send(equality_method, m1).should be_true
+      end
+
+      it 'returns true when the matchers are the same, but #match_attributes has its elements in a different order' do
+        m1, m2 = matcher, matcher
+        m1.match_attributes = [:method, :uri, :body, :headers]
+        m2.match_attributes = [:method, :body, :uri, :headers]
+        m1.send(equality_method, m2).should be_true
+        m2.send(equality_method, m1).should be_true
+      end
+
+      [:match_attributes, :method, :uri, :body, :headers].each do |different_attr|
+        it "returns false when ##{different_attr} is different, even when the request object is the same" do
+          m1, m2 = matchers_varying_on(different_attr)
+          m1.send(equality_method, m2).should be_false
+          m2.send(equality_method, m1).should be_false
+        end
+      end
+    end
+  end
+end