vcr 1.5.1 → 1.6.0

data/TODO.md

@@ -1,5 +0,0 @@
-* Use fakefs gem instead of using temp_dir in specs.
-* Fix #method vs .method in specs.
-* Cuke for Net::HTTP HTTPS request
-* Cuke for multiple simultaneous em-http-request
-* Ensure the checkpoints are properly deep-duped

data/lib/vcr/structs.rb

@@ -1,176 +0,0 @@
-require 'forwardable'
-
-module VCR
-  module BodyNormalizer
-    def initialize(*args)
-      super
-      normalize_body
-    end
-
-    private
-
-    def normalize_body
-      # Ensure that the body is a raw string, in case the string instance
-      # has been subclassed or extended with additional instance variables
-      # or attributes, so that it is serialized to YAML as a raw string.
-      # This is needed for rest-client.  See this ticket for more info:
-      # http://github.com/myronmarston/vcr/issues/4
-      self.body = case body
-        when nil, ''; nil
-        else String.new(body)
-      end
-    end
-  end
-
-  module HeaderNormalizer
-    # These headers get added by the various HTTP clients automatically,
-    # and we don't care about them.  We store the headers for the purposes
-    # of request matching, and we only care to match on headers users
-    # explicitly set.
-    HEADERS_TO_SKIP = {
-      'connection' => %w[ close Keep-Alive ],
-      'accept'     => %w[ */* ],
-      'expect'     => [''],
-      'user-agent' => ["Typhoeus - http://github.com/pauldix/typhoeus/tree/master", 'Ruby']
-    }
-
-    def initialize(*args)
-      super
-      normalize_headers
-    end
-
-    private
-
-    def important_header_values(k, values)
-      skip_values = HEADERS_TO_SKIP[k] || []
-      values - skip_values
-    end
-
-    def normalize_headers
-      new_headers = {}
-
-      headers.each do |k, v|
-        k = k.downcase
-
-        val_array = case v
-          when Array then v
-          when nil then []
-          else [v]
-        end
-
-        important_vals = important_header_values(k, val_array)
-        next unless important_vals.size > 0
-
-        # Ensure the values are raw strings.
-        # Apparently for Paperclip uploads to S3, headers
-        # get serialized with some extra stuff which leads
-        # to a seg fault. See this issue for more info:
-        # https://github.com/myronmarston/vcr/issues#issue/39
-        string_vals = important_vals.map { |v| String.new(v) }
-
-        new_headers[k] = string_vals
-      end if headers
-
-      self.headers = new_headers.empty? ? nil : new_headers
-    end
-  end
-
-  module URINormalizer
-    DEFAULT_PORTS = {
-      'http'  => 80,
-      'https' => 443
-    }
-
-    def initialize(*args)
-      super
-      normalize_uri
-    end
-
-    private
-
-    def normalize_uri
-      u = begin
-        URI.parse(uri)
-      rescue URI::InvalidURIError
-        return
-      end
-
-      u.port ||= DEFAULT_PORTS[u.scheme]
-
-      # URI#to_s only includes the port if it's not the default
-      # but we want to always include it (since FakeWeb/WebMock
-      # urls have always included it).  We force it to be included
-      # here by redefining default_port so that URI#to_s will include it.
-      def u.default_port; nil; end
-      self.uri = u.to_s
-    end
-  end
-
-  module StatusMessageNormalizer
-    def initialize(*args)
-      super
-      normalize_status_message
-    end
-
-    private
-
-    def normalize_status_message
-      self.message = message.strip if message
-      self.message = nil if message == ''
-    end
-  end
-
-  class Request < Struct.new(:method, :uri, :body, :headers)
-    include HeaderNormalizer
-    include URINormalizer
-    include BodyNormalizer
-
-    def self.from_net_http_request(net_http, request)
-      new(
-        request.method.downcase.to_sym,
-        VCR.http_stubbing_adapter.request_uri(net_http, request),
-        request.body,
-        request.to_hash
-      )
-    end
-
-    def matcher(match_attributes)
-      RequestMatcher.new(self, match_attributes)
-    end
-  end
-
-  class ResponseStatus < Struct.new(:code, :message)
-    include StatusMessageNormalizer
-
-    def self.from_net_http_response(response)
-      new(response.code.to_i, response.message)
-    end
-  end
-
-  class Response < Struct.new(:status, :headers, :body, :http_version)
-    include HeaderNormalizer
-    include BodyNormalizer
-
-    def self.from_net_http_response(response)
-      new(
-        ResponseStatus.from_net_http_response(response),
-        response.to_hash,
-        response.body,
-        response.http_version
-      )
-    end
-  end
-
-  class HTTPInteraction < Struct.new(:request, :response)
-    extend ::Forwardable
-    def_delegators :request, :uri, :method
-
-    def ignore!
-      @ignored = true
-    end
-
-    def ignored?
-      @ignored
-    end
-  end
-end

data/spec/vcr/structs_spec.rb

@@ -1,201 +0,0 @@
-require '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['some_header'].should == ['value1']
-    instance.headers['another'].should == ['a', 'b']
-  end
-
-  it 'removes empty headers' do
-    instance.headers.should_not have_key('third')
-    instance.headers.should_not have_key('fourth')
-  end
-
-  it 'filters out unimportant default values set by the HTTP library' do
-    instance = with_headers('accept' => ['*/*'], 'connection' => 'close', 'http-user' => ['foo'], 'expect' => ['', 'bar'])
-    instance.headers.should == { 'http-user' => ['foo'], 'expect' => ['bar'] }
-  end
-
-  it 'sets empty hash header to nil' do
-    with_headers({}).headers.should be_nil
-  end
-
-  it 'ensures header keys are serialized to yaml as raw strings' do
-    key = 'my-key'
-    key.instance_variable_set(:@foo, 7)
-    instance = with_headers(key => ['value1'])
-    instance.headers.to_yaml.should == { 'my-key' => ['value1'] }.to_yaml
-  end
-
-  it 'ensures header values are serialized to yaml as raw strings' do
-    value = 'my-value'
-    value.instance_variable_set(:@foo, 7)
-    instance = with_headers('my-key' => [value])
-    instance.headers.to_yaml.should == { 'my-key' => ['my-value'] }.to_yaml
-  end
-end
-
-shared_examples_for "a body normalizer" do
-  it 'sets empty string to nil' do
-    instance('').body.should be_nil
-  end
-
-  it "ensures the body is serialized to yaml as a raw string" do
-    body = "My String"
-    body.instance_variable_set(:@foo, 7)
-    instance(body).body.to_yaml.should == "My String".to_yaml
-  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 '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("#{VCR::SPEC_ROOT}/fixtures/#{YAML_SERIALIZATION_VERSION}/example_net_http.yml")) }
-    let(:request)  { YAML.load(File.read("#{VCR::SPEC_ROOT}/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 == { "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
-
-  it_behaves_like 'a header normalizer' do
-    def with_headers(headers)
-      described_class.new(:get, 'http://example.com/', nil, headers)
-    end
-  end
-
-  it_behaves_like 'a body normalizer' do
-    def instance(body)
-      described_class.new(:get, 'http://example.com/', body, {})
-    end
-  end
-end
-
-describe VCR::ResponseStatus do
-  describe '.from_net_http_response' do
-    let(:response) { YAML.load(File.read("#{VCR::SPEC_ROOT}/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
-
-  it 'chomps leading and trailing spaces on the status message' do
-    described_class.new(200, ' OK ').message.should == 'OK'
-  end
-
-  it 'sets status message to nil when it is the empty string' do
-    described_class.new(200, '').message.should be_nil
-    described_class.new(200, '  ').message.should be_nil
-  end
-end
-
-describe VCR::Response do
-  describe '.from_net_http_response' do
-    let(:response) { YAML.load(File.read("#{VCR::SPEC_ROOT}/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'],
-      "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
-
-  it_behaves_like 'a header normalizer' do
-    def with_headers(headers)
-      described_class.new(:status, headers, nil, '1.1')
-    end
-  end
-
-  it_behaves_like 'a body normalizer' do
-    def instance(body)
-      described_class.new(:status, {}, body, '1.1')
-    end
-  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
-
-  describe '#ignored?' do
-    it 'returns false by default' do
-      should_not be_ignored
-    end
-
-    it 'returns true when #ignore! has been called' do
-      subject.ignore!
-      should be_ignored
-    end
-  end
-end