vcr 2.0.0.beta1 → 2.0.0.beta2

data/lib/vcr/structs/normalizers/body.rb

@@ -1,24 +0,0 @@
-module VCR
-  module Normalizers
-    module Body
-      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
-  end
-end

data/lib/vcr/structs/normalizers/header.rb

@@ -1,64 +0,0 @@
-module VCR
-  module Normalizers
-    module Header
-      # 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/dbalatero/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
-
-          new_headers[k] = convert_to_raw_strings(important_vals)
-        end if headers
-
-        self.headers = new_headers.empty? ? nil : new_headers
-      end
-
-      def convert_to_raw_strings(array)
-        # 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
-        array.map do |v|
-          case v
-            when String; String.new(v)
-            when Array; convert_to_raw_strings(v)
-            else v
-          end
-        end
-      end
-    end
-  end
-end

data/lib/vcr/structs/normalizers/status_message.rb

@@ -1,17 +0,0 @@
-module VCR
-  module Normalizers
-    module StatusMessage
-      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
-  end
-end

data/lib/vcr/structs/normalizers/uri.rb

@@ -1,34 +0,0 @@
-module VCR
-  module Normalizers
-    module URI
-      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
-  end
-end

data/lib/vcr/structs/request.rb

@@ -1,13 +0,0 @@
-module VCR
-  class Request < Struct.new(:method, :uri, :body, :headers)
-    include Normalizers::Header
-    include Normalizers::URI
-    include Normalizers::Body
-
-    @@object_method = Object.instance_method(:method)
-    def method(*args)
-      return super if args.empty?
-      @@object_method.bind(self).call(*args)
-    end
-  end
-end

data/lib/vcr/structs/response.rb

@@ -1,13 +0,0 @@
-require 'vcr/structs/response_status'
-
-module VCR
-  class Response < Struct.new(:status, :headers, :body, :http_version)
-    include Normalizers::Header
-    include Normalizers::Body
-
-    def update_content_length_header
-      headers['content-length'] &&= [body ? body.length.to_s : '0']
-    end
-  end
-end
-

data/lib/vcr/structs/response_status.rb

@@ -1,5 +0,0 @@
-module VCR
-  class ResponseStatus < Struct.new(:code, :message)
-    include Normalizers::StatusMessage
-  end
-end

data/lib/vcr/util/yaml.rb

@@ -1,11 +0,0 @@
-require 'yaml'
-
-module VCR
-  # Attempt to use psych if it is available.
-  YAML = begin
-    require 'psych'
-    Psych
-  rescue LoadError
-    ::YAML
-  end
-end

data/spec/support/shared_example_groups/normalizers.rb

@@ -1,94 +0,0 @@
-shared_examples_for "header normalization" 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 eq(['value1'])
-    instance.headers['another'].should eq(['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 eq({ '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'])
-    VCR::YAML.dump(instance.headers).should eq(VCR::YAML.dump('my-key' => ['value1']))
-  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])
-    VCR::YAML.dump(instance.headers).should eq(VCR::YAML.dump('my-key' => ['my-value']))
-  end
-
-  it 'handles nested arrays' do
-    accept_encoding = [["gzip", "1.0"], ["deflate", "1.0"], ["sdch", "1.0"]]
-    instance = with_headers('accept-encoding' => accept_encoding)
-    instance.headers['accept-encoding'].should eq(accept_encoding)
-  end
-
-  it 'handles nested arrays with floats' do
-    accept_encoding = [["gzip", 1.0], ["deflate", 1.0], ["sdch", 1.0]]
-    instance = with_headers('accept-encoding' => accept_encoding)
-    instance.headers['accept-encoding'].should eq(accept_encoding)
-  end
-end
-
-shared_examples_for "body normalization" 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)
-    VCR::YAML.dump(instance(body).body).should eq(VCR::YAML.dump("My String"))
-  end
-end
-
-shared_examples_for 'uri normalization' do
-  it 'adds port 80 to an http URI that lacks a port' do
-    instance('http://example.com/foo').uri.should eq('http://example.com:80/foo')
-  end
-
-  it 'keeps the existing port for an http URI' do
-    instance('http://example.com:8000/foo').uri.should eq('http://example.com:8000/foo')
-  end
-
-  it 'adds port 443 to an https URI that lacks a port' do
-    instance('https://example.com/foo').uri.should eq('https://example.com:443/foo')
-  end
-
-  it 'keeps the existing port for an https URI' do
-    instance('https://example.com:8000/foo').uri.should eq('https://example.com:8000/foo')
-  end
-end
-
-shared_examples_for 'status message normalization' do
-  it 'chomps leading and trailing spaces on the status message' do
-    instance(' OK ').message.should eq('OK')
-  end
-
-  it 'sets status message to nil when it is the empty string' do
-    instance('').message.should be_nil
-  end
-
-  it 'sets status message to nil when it is a blank string' do
-    instance('  ').message.should be_nil
-  end
-end

data/spec/vcr/structs/http_interaction_spec.rb

@@ -1,89 +0,0 @@
-require 'spec_helper'
-
-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 eq(: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
-
-  it 'does not include `@ignored` in the serialized output' do
-    subject.ignore!
-    VCR::YAML.dump(subject).should_not include('ignored')
-  end
-
-  describe '#filter!' do
-    let(:response_status) { VCR::ResponseStatus.new(200, "OK foo") }
-    let(:body) { "The body foo this is (foo-Foo)" }
-    let(:headers) do {
-      'x-http-foo' => ['bar23', '23foo'],
-      'x-http-bar' => ['foo23', '18']
-    } end
-
-    let(:response) do
-      VCR::Response.new(
-        response_status,
-        headers.dup,
-        body.dup,
-        '1.1'
-      )
-    end
-
-    let(:request) do
-      VCR::Request.new(
-        :get,
-        'http://example-foo.com:80/foo/',
-        body.dup,
-        headers.dup
-      )
-    end
-
-    let(:interaction) { VCR::HTTPInteraction.new(request, response) }
-
-    subject { interaction.filter!('foo', 'AAA') }
-
-    it 'does nothing when given a blank argument' do
-      expect {
-        interaction.filter!(nil, 'AAA')
-        interaction.filter!('foo', nil)
-        interaction.filter!("", 'AAA')
-        interaction.filter!('foo', "")
-      }.not_to change { interaction }
-    end
-
-    [:request, :response].each do |part|
-      it "replaces the sensitive text in the #{part} header keys and values" do
-        subject.send(part).headers.should eq({
-          'x-http-AAA' => ['bar23', '23AAA'],
-          'x-http-bar' => ['AAA23', '18']
-        })
-      end
-
-      it "replaces the sensitive text in the #{part} body" do
-        subject.send(part).body.should eq("The body AAA this is (AAA-Foo)")
-      end
-    end
-
-    it 'replaces the sensitive text in the response status' do
-      subject.response.status.message.should eq('OK AAA')
-    end
-
-    it 'replaces sensitive text in the request URI' do
-      subject.request.uri.should eq('http://example-AAA.com:80/AAA/')
-    end
-  end
-end

data/spec/vcr/structs/request_spec.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-
-describe VCR::Request do
-  describe '#method' do
-    subject { VCR::Request.new(:get) }
-
-    context 'when given no arguments' do
-      it 'returns the HTTP method' do
-        subject.method.should eq(:get)
-      end
-    end
-
-    context 'when given an argument' do
-      it 'returns the method object for the named method' do
-        m = subject.method(:class)
-        m.should be_a(Method)
-        m.call.should eq(described_class)
-      end
-    end
-  end
-
-  it_performs 'uri normalization' do
-    def instance(uri)
-      VCR::Request.new(:get, uri, '', {})
-    end
-  end
-
-  it_performs 'header normalization' do
-    def with_headers(headers)
-      described_class.new(:get, 'http://example.com/', nil, headers)
-    end
-  end
-
-  it_performs 'body normalization' do
-    def instance(body)
-      described_class.new(:get, 'http://example.com/', body, {})
-    end
-  end
-end

data/spec/vcr/structs/response_spec.rb

@@ -1,44 +0,0 @@
-require 'spec_helper'
-
-describe VCR::Response do
-  it_performs 'header normalization' do
-    def with_headers(headers)
-      described_class.new(:status, headers, nil, '1.1')
-    end
-  end
-
-  it_performs 'body normalization' do
-    def instance(body)
-      described_class.new(:status, {}, body, '1.1')
-    end
-  end
-
-  describe '#update_content_length_header' do
-    def instance(body, content_length = nil)
-      headers = { 'content-type' => 'text' }
-      headers.merge!('content-length' => content_length) if content_length
-      described_class.new(VCR::ResponseStatus.new, headers, body)
-    end
-
-    it 'does nothing when the response lacks a content_length header' do
-      inst = instance('the body')
-      expect {
-        inst.update_content_length_header
-      }.not_to change { inst.headers['content-length'] }
-    end
-
-    it 'sets the content_length header to the response body length when the header is present' do
-      inst = instance('the body', '3')
-      expect {
-        inst.update_content_length_header
-      }.to change { inst.headers['content-length'] }.from(['3']).to(['8'])
-    end
-
-    it 'sets the content_length header to 0 if the response body is nil' do
-      inst = instance(nil, '3')
-      expect {
-        inst.update_content_length_header
-      }.to change { inst.headers['content-length'] }.from(['3']).to(['0'])
-    end
-  end
-end