mustwin-vcr 2.9.3

data/spec/spec_helper.rb

@@ -0,0 +1,62 @@
+require "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
+
+require "pry"
+require "rspec"
+require "vcr"
+require "date"
+require "forwardable"
+require "uri"
+require "vcr/util/internet_connection"
+require_relative "support/fixnum_extension"
+require_relative "support/limited_uri"
+require_relative "support/ruby_interpreter"
+require_relative "support/shared_example_groups/hook_into_http_library"
+require_relative "support/shared_example_groups/request_hooks"
+require_relative "support/vcr_stub_helpers"
+require_relative "support/vcr_localhost_server"
+require_relative "support/sinatra_app"
+require_relative "monkey_patches"
+require_relative "support/http_library_adapters"
+
+module VCR
+  SPEC_ROOT = File.dirname(File.expand_path('.', __FILE__))
+
+  def reset!(hook = :fakeweb)
+    instance_variables.each do |ivar|
+      instance_variable_set(ivar, nil)
+    end
+    configuration.hook_into hook if hook
+  end
+end
+
+RSpec.configure do |config|
+  tmp_dir = File.expand_path('../../tmp/cassette_library_dir', __FILE__)
+  config.before(:each) do |example|
+    unless example.metadata[:skip_vcr_reset]
+      VCR.reset!
+      VCR.configuration.cassette_library_dir = tmp_dir
+      VCR.configuration.uri_parser = LimitedURI
+    end
+  end
+
+  config.after(:each) do
+    FileUtils.rm_rf tmp_dir
+  end
+
+  config.before(:all, :disable_warnings => true) do
+    @orig_std_err = $stderr
+    $stderr = StringIO.new
+  end
+
+  config.after(:all, :disable_warnings => true) do
+    $stderr = @orig_std_err
+  end
+
+  config.filter_run :focus => true
+  config.run_all_when_everything_filtered = true
+
+  config.alias_it_should_behave_like_to :it_performs, 'it performs'
+end
+
+VCR::SinatraApp.boot

data/spec/support/configuration_stubbing.rb

@@ -0,0 +1,8 @@
+shared_context "configuration stubbing" do
+  let(:config) { double("VCR::Configuration") }
+
+  before do
+    allow(VCR).to receive(:configuration) { config }
+  end
+end
+

data/spec/support/cucumber_helpers.rb

@@ -0,0 +1,35 @@
+module Gem
+  def self.win_platform?() false end
+end unless defined?(Gem)
+
+# pretend we're always on the internet (so that we don't have an
+# internet connection dependency for our cukes)
+VCR::InternetConnection.class_eval do
+  def available?; true; end
+end
+
+if ENV['DATE_STRING']
+  require 'timecop'
+  Timecop.travel(Date.parse(ENV['DATE_STRING']))
+end
+
+def include_http_adapter_for(lib)
+  require((lib =~ /faraday/) ? 'faraday' : lib)
+  require 'typhoeus' if lib.include?('typhoeus') # for faraday-typhoeus
+  require 'support/http_library_adapters'
+  include HTTP_LIBRARY_ADAPTERS[lib]
+end
+
+def response_body_for(*args)
+  get_body_string(make_http_request(*args))
+end
+
+def start_sinatra_app(&block)
+  require 'sinatra/base'
+  require 'support/vcr_localhost_server'
+  klass = Class.new(Sinatra::Base)
+  klass.disable :protection
+  klass.class_eval(&block)
+
+  VCR::LocalhostServer.new(klass.new)
+end

data/spec/support/fixnum_extension.rb

@@ -0,0 +1,10 @@
+unless 7.respond_to?(:days)
+  class Fixnum
+    def days
+      self *
+      24 * # hours
+      60 * # minutes
+      60   # seconds
+    end
+  end
+end

data/spec/support/http_library_adapters.rb

@@ -0,0 +1,289 @@
+module HeaderDowncaser
+  def downcase_headers(headers)
+    {}.tap do |downcased|
+      headers.each do |k, v|
+        downcased[k.downcase] = v
+      end
+    end
+  end
+end
+
+HTTP_LIBRARY_ADAPTERS = {}
+
+HTTP_LIBRARY_ADAPTERS['net/http'] = Module.new do
+  include HeaderDowncaser
+
+  def self.http_library_name; 'Net::HTTP'; end
+
+  def get_body_string(response); response.body; end
+  alias get_body_object get_body_string
+
+  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)
+    http = Net::HTTP.new(uri.host, uri.port)
+
+    if uri.scheme == "https"
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    end
+
+    http.send_request(method.to_s.upcase, uri.request_uri, body, headers)
+  end
+
+  DEFAULT_REQUEST_HEADERS = { "Accept"=>["*/*"] }
+  DEFAULT_REQUEST_HEADERS['User-Agent'] = ["Ruby"] if RUBY_VERSION.to_f > 1.8
+  DEFAULT_REQUEST_HEADERS['Accept-Encoding'] = ["gzip;q=1.0,deflate;q=0.6,identity;q=0.3"] if RUBY_VERSION.to_f > 1.9
+
+  def normalize_request_headers(headers)
+    defined?(super) ? super :
+    downcase_headers(headers.merge(DEFAULT_REQUEST_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
+  alias get_body_object get_body_string
+
+  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
+
+  def normalize_request_headers(headers)
+    headers.merge('Expect' => [''])
+  end
+end
+
+HTTP_LIBRARY_ADAPTERS['httpclient'] = Module.new do
+  def self.http_library_name; 'HTTP Client'; end
+
+  def get_body_string(response)
+    body = response.body
+    string = body.is_a?(String) ? body : body.content
+    string.respond_to?(:read) ? string.read : string
+  end
+
+  def get_body_object(response)
+    response.body
+  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
+
+  def normalize_request_headers(headers)
+    headers.merge({
+      'Accept'     => ["*/*"],
+      'User-Agent' => ["HTTPClient/1.0 (#{HTTPClient::VERSION}, ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}))"],
+      'Date'       => [Time.now.httpdate]
+    })
+  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
+  alias get_body_object get_body_string
+
+  def get_header(header_key, response)
+    values = response.response_header[header_key.upcase.gsub('-', '_')]
+    values.is_a?(Array) ? values : values.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
+
+  def normalize_request_headers(headers)
+    headers
+  end
+end
+
+HTTP_LIBRARY_ADAPTERS['curb'] = Module.new do
+  def self.http_library_name; "Curb"; end
+
+  def get_body_string(response)
+    response.body_str
+  end
+  alias get_body_object get_body_string
+
+  def get_header(header_key, response)
+    headers = response.header_str.split("\r\n")[1..-1]
+    value = nil
+    headers.each do |h|
+      next unless h =~ /^#{Regexp.escape(header_key)}: (.*)$/
+      new_value = $1.split(', ')
+      value = value ? Array(value) + Array(new_value) : new_value
+    end
+    value
+  end
+
+  def make_http_request(method, url, body = nil, headers = {})
+    Curl::Easy.new(url) do |c|
+      c.headers = headers
+
+      if [:post, :put].include?(method)
+        c.send("http_#{method}", body)
+      else
+        c.send("http_#{method}")
+      end
+    end
+  end
+
+  def normalize_request_headers(headers)
+    headers
+  end
+end
+
+HTTP_LIBRARY_ADAPTERS['typhoeus'] = Module.new do
+  def self.http_library_name; "Typhoeus"; end
+
+  def get_body_string(response)
+    response.body
+  end
+  alias get_body_object get_body_string
+
+  def get_header(header_key, response)
+    # Due to https://github.com/typhoeus/typhoeus/commit/256c95473d5d40d7ec2f5db603687323ddd73689
+    # headers are now downcased.
+    # ...except when they're not.  I'm not 100% why (I haven't had time to dig into it yet)
+    # but in some situations the headers aren't downcased.  I think it has to do with playback; VCR
+    # isn't sending the headers in downcased to typhoeus. It gets complicated with the interaction
+    # w/ WebMock, and the fact that webmock normalizes headers in a different fashion.
+    #
+    # For now this hack works.
+    response.headers.fetch(header_key.downcase) { response.headers[header_key] }
+  end
+
+  def make_http_request(method, url, body = nil, headers = {})
+    request = Typhoeus::Request.new(url, :method => method, :body => body, :headers => headers)
+    request.run
+    request.response
+  end
+
+  def normalize_request_headers(headers)
+    headers.merge("User-Agent"=>["Typhoeus - https://github.com/typhoeus/typhoeus"])
+  end
+end
+
+HTTP_LIBRARY_ADAPTERS['typhoeus 0.4'] = Module.new do
+  def self.http_library_name; "Typhoeus"; end
+
+  def get_body_string(response)
+    response.body
+  end
+  alias get_body_object get_body_string
+
+  def get_header(header_key, response)
+    response.headers_hash[header_key]
+  end
+
+  def make_http_request(method, url, body = nil, headers = {})
+    Typhoeus::Request.send(method, url, :body => body, :headers => headers)
+  end
+
+  def normalize_request_headers(headers)
+    headers
+  end
+end
+
+HTTP_LIBRARY_ADAPTERS['excon'] = Module.new do
+  def self.http_library_name; "Excon"; end
+
+  def get_body_string(response)
+    response.body
+  end
+  alias get_body_object get_body_string
+
+  def get_header(header_key, response)
+    response.headers[header_key]
+  end
+
+  def make_http_request(method, url, body = nil, headers = {})
+    # There are multiple ways to use Excon but this is how fog (the main user of excon) uses it:
+    # https://github.com/fog/fog/blob/v1.1.1/lib/fog/aws/rds.rb#L139-147
+    Excon.new(url).request(:method => method.to_s.upcase, :body => body, :headers => headers)
+  end
+
+  def normalize_request_headers(headers)
+    headers.merge('User-Agent' => [Excon::USER_AGENT])
+  end
+end
+
+%w[ net_http typhoeus patron ].each do |_faraday_adapter|
+  if _faraday_adapter == 'typhoeus' &&
+     defined?(::Typhoeus::VERSION) &&
+     ::Typhoeus::VERSION.to_f >= 0.5
+    require 'typhoeus/adapters/faraday'
+  end
+
+  HTTP_LIBRARY_ADAPTERS["faraday (w/ #{_faraday_adapter})"] = Module.new do
+    class << self; self; end.class_eval do
+      define_method(:http_library_name) do
+        "Faraday (#{_faraday_adapter})"
+      end
+    end
+
+    define_method(:faraday_adapter) { _faraday_adapter.to_sym }
+
+    def get_body_string(response)
+      response.body
+    end
+    alias get_body_object get_body_string
+
+    def get_header(header_key, response)
+      value = response.headers[header_key]
+      value.split(', ') if value
+    end
+
+    def make_http_request(method, url, body = nil, headers = {})
+      url_root, url_rest = split_url(url)
+
+      faraday_connection(url_root).send(method) do |req|
+        req.url url_rest
+        headers.each { |k, v| req[k] = v }
+        req.body = body if body
+      end
+    end
+
+    def split_url(url)
+      uri = URI.parse(url)
+      url_root = "#{uri.scheme}://#{uri.host}:#{uri.port}"
+      rest = url.sub(url_root, '')
+
+      [url_root, rest]
+    end
+
+    def faraday_connection(url_root)
+      Faraday::Connection.new(:url => url_root) do |builder|
+        builder.adapter faraday_adapter
+      end
+    end
+
+    def normalize_request_headers(headers)
+      headers.merge("User-Agent" => ["Faraday v#{Faraday::VERSION}"])
+    end
+  end
+end
+

data/spec/support/limited_uri.rb

@@ -0,0 +1,21 @@
+class LimitedURI
+  extend Forwardable
+
+  def_delegators :@uri, :scheme, :host, :port, :port=, :path, :query, :query=, :to_s
+
+  def initialize(uri)
+    @uri = uri
+  end
+
+  def ==(other)
+    to_s == other.to_s
+  end
+
+  def self.parse(uri)
+    return uri if uri.is_a? LimitedURI
+    return new(uri) if uri.is_a? URI
+    return new(URI.parse(uri)) if uri.is_a? String
+
+    raise URI::InvalidURIError
+  end
+end

data/spec/support/ruby_interpreter.rb

@@ -0,0 +1,7 @@
+RUBY_INTERPRETER = if RUBY_PLATFORM == 'java'
+  :jruby
+elsif defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
+  :rubinius
+else
+  :mri
+end

data/spec/support/shared_example_groups/excon.rb

@@ -0,0 +1,63 @@
+shared_examples "Excon streaming" do
+  context "when Excon's streaming API is used" do
+    def make_request_to(path)
+      chunks = []
+
+      Excon.get "http://localhost:#{VCR::SinatraApp.port}#{path}", :response_block => lambda { |chunk, remaining_bytes, total_bytes|
+        chunks << chunk
+      }
+
+      chunks.join
+    end
+
+    it 'properly records and plays back the response' do
+      allow(VCR).to receive(:real_http_connections_allowed?).and_return(true)
+      recorded, played_back = [1, 2].map do
+        make_request_to('/foo')
+      end
+
+      expect(recorded).to eq(played_back)
+      expect(recorded).to eq("FOO!")
+    end
+
+    it 'properly records and plays back the response for unexpected status' do
+      allow(VCR).to receive(:real_http_connections_allowed?).and_return(true)
+      recorded, played_back = [1, 2].map do
+        chunks = []
+
+        VCR.use_cassette('excon_streaming_error', :record => :once) do
+          begin
+            Excon.get "http://localhost:#{VCR::SinatraApp.port}/404_not_200", :expects => 200, :response_block => lambda { |chunk, remaining_bytes, total_bytes|
+              chunks << chunk
+            }
+          rescue Excon::Errors::Error => e
+            chunks << e.response.body
+          end
+        end
+
+        chunks.join
+      end
+
+      expect(recorded).to eq(played_back)
+      expect(recorded).to eq('404 not 200')
+    end
+
+    context "when a cassette is played back and appended to" do
+      it 'does not allow Excon to mutate the response body in the cassette' do
+        VCR.use_cassette('excon_streaming', :record => :new_episodes) do
+          expect(make_request_to('/')).to eq('GET to root')
+        end
+
+        VCR.use_cassette('excon_streaming', :record => :new_episodes) do
+          expect(make_request_to('/')).to eq('GET to root')
+          expect(make_request_to('/foo')).to eq('FOO!') # so it will save to disk again
+        end
+
+        VCR.use_cassette('excon_streaming', :record => :new_episodes) do
+          expect(make_request_to('/')).to eq('GET to root')
+        end
+      end
+    end
+  end
+end
+