vcr 3.0.3 → 4.0.0

data/spec/support/shared_example_groups/request_hooks.rb

@@ -1,59 +0,0 @@
-shared_examples_for "request hooks" do |library_hook_name, request_type|
-  let(:request_url) { "http://localhost:#{VCR::SinatraApp.port}/foo" }
-
-  def make_request(disabled = false)
-    make_http_request(:get, request_url)
-  end
-
-  def assert_expected_response(response)
-    expect(response.status.code).to eq(200)
-    expect(response.body).to eq('FOO!')
-  end
-
-  [:before_http_request, :after_http_request].each do |hook|
-    specify "the #{hook} hook is only called once per request" do
-      call_count = 0
-      VCR.configuration.send(hook) { |r| call_count += 1 }
-
-      make_request
-      expect(call_count).to eq(1)
-    end
-
-    specify "the #{hook} hook yields the request" do
-      request = nil
-      VCR.configuration.send(hook) { |r| request = r }
-
-      make_request
-      expect(request.method).to be(:get)
-      expect(request.uri).to eq(request_url)
-    end
-
-    specify "the #{hook} hook is not called if the library hook is disabled" do
-      expect(VCR.library_hooks).to respond_to(:disabled?)
-      allow(VCR.library_hooks).to receive(:disabled?).and_return(true)
-
-      hook_called = false
-      VCR.configuration.send(hook) { |r| hook_called = true }
-
-      make_request(:disabled)
-      expect(hook_called).to be false
-    end
-
-    specify "the #type of the yielded request given to the #{hook} hook is #{request_type}" do
-      request = nil
-      VCR.configuration.send(hook) { |r| request = r }
-
-      make_request
-      expect(request.type).to be(request_type)
-    end
-  end
-
-  specify "the after_http_request hook yields the response if there is one and the second block arg is given" do
-    response = nil
-    VCR.configuration.after_http_request { |req, res| response = res }
-
-    make_request
-    assert_expected_response(response)
-  end
-end
-

data/spec/support/sinatra_app.rb

@@ -1,86 +0,0 @@
-require 'sinatra'
-
-module VCR
-  class SinatraApp < ::Sinatra::Base
-    disable :protection
-
-    get '/' do
-      "GET to root"
-    end
-
-    get '/search' do
-      "query: #{params[:q]}"
-    end
-
-    get '/localhost_test' do
-      "Localhost response"
-    end
-
-    get '/foo' do
-      "FOO!"
-    end
-
-    get '/redirect-to-root' do
-      redirect to('/')
-    end
-
-    post '/foo' do
-      "FOO!"
-    end
-
-    post '/return-request-body' do
-      request.body
-    end
-
-    get '/set-cookie-headers/1' do
-      headers 'Set-Cookie' => 'foo'
-      'header set'
-    end
-
-    get '/set-cookie-headers/2' do
-      headers 'Set-Cookie' => %w[ bar foo ]
-      'header set'
-    end
-
-    get '/204' do
-      status 204
-    end
-
-    get '/404_not_200' do
-      status 404
-      '404 not 200'
-    end
-
-    # we use a global counter so that every response is different;
-    # this ensures that the test demonstrates that the response
-    # is being played back (and not running a 2nd real request)
-    $record_and_playback_response_count ||= 0
-    get '/record-and-playback' do
-      "Response #{$record_and_playback_response_count += 1}"
-    end
-
-    post '/record-and-playback' do
-      "Response #{$record_and_playback_response_count += 1}"
-    end
-
-    @_boot_failed = false
-
-    class << self
-      def port
-        server.port
-      end
-
-      def server
-        raise "Sinatra app failed to boot." if @_boot_failed
-        @server ||= begin
-          VCR::LocalhostServer.new(new)
-        rescue
-          @_boot_failed = true
-          raise
-        end
-      end
-
-      alias boot server
-    end
-  end
-end

data/spec/support/vcr_localhost_server.rb

@@ -1,76 +0,0 @@
-require 'rack'
-require 'rack/handler/webrick'
-require 'net/http'
-
-# The code for this is inspired by Capybara's server:
-#   http://github.com/jnicklas/capybara/blob/0.3.9/lib/capybara/server.rb
-module VCR
-  class LocalhostServer
-    READY_MESSAGE = "VCR server ready"
-
-    class Identify
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        if env["PATH_INFO"] == "/__identify__"
-          [200, {}, [VCR::LocalhostServer::READY_MESSAGE]]
-        else
-          @app.call(env)
-        end
-      end
-    end
-
-    attr_reader :port
-
-    def initialize(rack_app, port = nil)
-      @port = port || find_available_port
-      @rack_app = rack_app
-      concurrently { boot }
-      wait_until(30, "Boot failed.") { booted? }
-    end
-
-    private
-
-    def find_available_port
-      server = TCPServer.new('127.0.0.1', 0)
-      server.addr[1]
-    ensure
-      server.close if server
-    end
-
-    def boot
-      # Use WEBrick since it's part of the ruby standard library and is available on all ruby interpreters.
-      options = { :Port => port, :ShutdownSocketWithoutClose => true }
-      options.merge!(:AccessLog => [], :Logger => WEBrick::BasicLog.new(StringIO.new)) unless ENV['VERBOSE_SERVER']
-      Rack::Handler::WEBrick.run(Identify.new(@rack_app), options)
-    end
-
-    def booted?
-      res = ::Net::HTTP.get_response("localhost", '/__identify__', port)
-      if res.is_a?(::Net::HTTPSuccess) or res.is_a?(::Net::HTTPRedirection)
-        return res.body == READY_MESSAGE
-      end
-    rescue Errno::ECONNREFUSED, Errno::EBADF
-      return false
-    end
-
-    def concurrently
-      # JRuby doesn't support forking.
-      # Rubinius does, but there's a weird issue with the booted? check not working,
-      # so we're just using a thread for now.
-      Thread.new { yield }
-    end
-
-    def wait_until(timeout, error_message, &block)
-      start_time = Time.now
-
-      while true
-        return if yield
-        raise TimeoutError.new(error_message) if (Time.now - start_time) > timeout
-        sleep(0.01)
-      end
-    end
-  end
-end

data/spec/support/vcr_stub_helpers.rb

@@ -1,17 +0,0 @@
-module VCRStubHelpers
-  def interactions_from(file)
-    hashes = YAML.load_file(File.join(VCR::SPEC_ROOT, 'fixtures', file))['http_interactions']
-    hashes.map { |h| VCR::HTTPInteraction.from_hash(h) }
-  end
-
-  def stub_requests(*args)
-    allow(VCR).to receive(:http_interactions).and_return(VCR::Cassette::HTTPInteractionList.new(*args))
-  end
-
-  def http_interaction(url, response_body = "FOO!", status_code = 200)
-    request = VCR::Request.new(:get, request_url)
-    response_status = VCR::ResponseStatus.new(status_code)
-    response = VCR::Response.new(response_status, nil, response_body, '1.1')
-    VCR::HTTPInteraction.new(request, response)
-  end
-end