vcr 1.11.3 → 2.0.0.beta1

data/spec/vcr/http_stubbing_adapters/multi_object_proxy_spec.rb

@@ -1,101 +0,0 @@
-require 'spec_helper'
-
-module VCR
-  module HttpStubbingAdapters
-    describe MultiObjectProxy do
-      let(:mock1) { mock }
-      let(:mock2) { mock }
-      subject { described_class.new(mock1, mock2) }
-
-      it 'raises an error when it is created with no objects' do
-        expect { described_class.new }.to raise_error(ArgumentError)
-      end
-
-      it 'raises an error when one of the objects is nil' do
-        expect { described_class.new(Object.new, nil) }.to raise_error(ArgumentError)
-      end
-
-      it 'is a basic object with very few of its own methods' do
-        inst_methods = described_class.instance_methods.map { |m| m.to_sym }
-        inst_methods.should_not include(:send, :object_id)
-      end
-
-      describe '#proxied_objects' do
-        it 'returns the proxied objects' do
-          subject.proxied_objects.should eq([mock1, mock2])
-        end
-      end
-
-      describe '#respond_to?' do
-        it 'responds to any method that any of the objects responds to' do
-          mock1.stub(:respond_to?).with(:foo).and_return(true)
-          mock1.stub(:respond_to?).with(:bar).and_return(false)
-          mock2.stub(:respond_to?).with(:bar).and_return(true)
-          mock2.stub(:respond_to?).with(:foo).and_return(false)
-
-          subject.respond_to?(:foo).should be_true
-          subject.respond_to?(:bar).should be_true
-        end
-
-        it 'does not respond to a method that none of the objects respond to' do
-          subject.respond_to?(:bazz).should be_false
-        end
-      end
-
-      describe 'calling a method' do
-        it 'raises a no method error when none of the objects responds to the method' do
-          expect { subject.some_undefined_method }.to raise_error(NoMethodError)
-        end
-
-        it 'properly proxies messages to a single object when only one object responds to the message' do
-          mock1.should_not respond_to(:request_stubbed?)
-          mock2.should_receive(:request_stubbed?).and_return(true)
-
-          subject.request_stubbed?.should eq(true)
-        end
-
-        it 'proxies messages to each object' do
-          mock1.should_receive(:stub_requests).with(:arg1, :arg2)
-          mock2.should_receive(:stub_requests).with(:arg1, :arg2)
-
-          subject.stub_requests(:arg1, :arg2)
-        end
-
-        [:http_connections_allowed?, :request_uri].each do |method|
-          context "for ##{method}" do
-            it 'raises an error if the the objects return different values' do
-              mock1.should_receive(method).and_return(:return_value_1)
-              mock2.should_receive(method).and_return(:return_value_2)
-
-              expect { subject.__send__(method) }.to raise_error(/proxied objects returned different values/)
-            end
-
-            it 'returns the value returned by both objects when they return the same value' do
-              mock1.should_receive(method).and_return(:return_value_1)
-              mock2.should_receive(method).and_return(:return_value_1)
-
-              subject.__send__(method).should eq(:return_value_1)
-            end
-          end
-        end
-
-        context 'for a non-predicate method' do
-          it 'does not raise an error when the objects have different return values' do
-            mock1.should_receive(:stub_requests).and_return(:val1)
-            mock2.should_receive(:stub_requests).and_return(:val2)
-
-            subject.stub_requests
-          end
-
-          it 'returns nil regardless of the return values of the objects' do
-            mock1.should_receive(:stub_requests).and_return(:val1)
-            mock2.should_receive(:stub_requests).and_return(:val1)
-
-            subject.stub_requests.should be_nil
-          end
-        end
-      end
-    end
-  end
-end
-

data/spec/vcr/http_stubbing_adapters/webmock_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-describe VCR::HttpStubbingAdapters::WebMock, :with_monkey_patches => :webmock do
-  it_behaves_like 'an http stubbing adapter',
-    %w[net/http patron httpclient em-http-request curb],
-    [:method, :uri, :host, :path, :body, :headers]
-
-  it_performs('version checking',
-    :valid    => %w[ 1.7.0 1.7.99 ],
-    :too_low  => %w[ 0.9.9 0.9.10 0.1.30 1.0.30 1.6.9 ],
-    :too_high => %w[ 1.8.0 1.10.0 2.0.0 ]
-  ) do
-    def stub_version(version)
-      WebMock.stub(:version).and_return(version)
-    end
-  end
-end

data/spec/vcr/middleware/cassette_arguments_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-
-describe VCR::Middleware::CassetteArguments do
-  describe '#name' do
-    it 'initially returns nil' do
-      subject.name.should be_nil
-    end
-
-    it 'stores the given value, returning it when no arg is given' do
-      subject.name :value1
-      subject.name.should eq(:value1)
-
-      subject.name :value2
-      subject.name.should eq(:value2)
-    end
-  end
-
-  describe '#options' do
-    it 'initially returns an empty hash' do
-      subject.options.should eq({})
-    end
-
-    it 'merges the given hash options, returning them when no arg is given' do
-      subject.options :record => :new_episodes
-      subject.options.should eq({ :record => :new_episodes })
-
-      subject.options :erb => true
-      subject.options.should eq({ :record => :new_episodes, :erb => true })
-    end
-  end
-end
-

data/spec/vcr/request_matcher_spec.rb

@@ -1,230 +0,0 @@
-require '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 { 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 eq(/.*/) }
-    end
-
-    for_matcher :uri do
-      it("returns the exact uri") { should eq(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 =~ 'https://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 eq(/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 eq(: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 eq('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 eq({ '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
-
-  def matcher_with_headers(headers)
-    VCR::RequestMatcher.new(VCR::Request.new(:get, 'http://foo.com/', nil, headers), [:method, :uri, :headers])
-  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 eq(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 eq(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
-
-    context 'for headers' do
-      it 'returns the same code for the same headers' do
-        m1 = matcher_with_headers('x-http-header' => ['val1'])
-        m2 = matcher_with_headers('x-http-header' => ['val1'])
-        m1.hash.should eq(m2.hash)
-      end
-
-      it 'returns the same code when the header keys are ordered differently' do
-        m1 = matcher_with_headers('x-http-header1' => ['val1'], 'x-http-header2' => ['val2'])
-        m2 = matcher_with_headers('x-http-header2' => ['val2'], 'x-http-header1' => ['val1'])
-        m1.hash.should eq(m2.hash)
-      end
-
-      it 'returns the same code when the header value arrays are ordered differently' do
-        m1 = matcher_with_headers('x-http-header' => ['val1', 'val2'])
-        m2 = matcher_with_headers('x-http-header' => ['val2', 'val1'])
-        m1.hash.should eq(m2.hash)
-      end
-
-      it 'returns a different code when the header values are different' do
-        m1 = matcher_with_headers('x-http-header' => ['val1'])
-        m2 = matcher_with_headers('x-http-header' => ['val2'])
-        m1.hash.should_not == m2.hash
-      end
-
-      it 'returns a different code when the header keys are different' do
-        m1 = matcher_with_headers('x-http-header1' => ['val1'])
-        m2 = matcher_with_headers('x-http-header2' => ['val1'])
-        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