vcr 3.0.3 → 6.1.0

data/features/http_libraries/em_http_request.feature

@@ -1,250 +0,0 @@
-@exclude-jruby @exclude-rbx
-Feature: EM HTTP Request
-
-  EM HTTP Request allows multiple simultaneous asynchronous requests.
-  (The other HTTP libraries are synchronous).  The scenarios below
-  demonstrate how VCR can be used with asynchronous em-http requests.
-
-  Background:
-    Given a file named "vcr_setup.rb" with:
-      """ruby
-      require 'em-http-request'
-
-      $server = start_sinatra_app do
-        %w[ foo bar bazz ].each_with_index do |path, index|
-          get "/#{path}" do
-            sleep index * 0.1 # ensure the async callbacks are invoked in order
-            ARGV[0] + ' ' + path
-          end
-        end
-      end
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-        c.before_record do |i|
-          i.request.uri.sub!(/:\d+/, ':7777')
-        end
-      end
-      """
-
-  Scenario: multiple simultaneous HttpRequest objects
-    Given a file named "make_requests.rb" with:
-      """ruby
-      require 'vcr_setup'
-
-      VCR.use_cassette('em_http') do
-        EventMachine.run do
-          http_array = %w[ foo bar bazz ].map do |p|
-            EventMachine::HttpRequest.new("http://localhost:#{$server.port}/#{p}").get
-          end
-
-          http_array.each do |http|
-            http.callback do
-              puts http.response
-
-              if http_array.all? { |h| h.response.to_s != '' }
-                EventMachine.stop
-              end
-            end
-          end
-        end
-      end
-      """
-    When I run `ruby make_requests.rb Hello`
-    Then the output should contain:
-      """
-      Hello foo
-      Hello bar
-      Hello bazz
-      """
-    And the file "cassettes/em_http.yml" should contain YAML like:
-      """
-      --- 
-      http_interactions: 
-      - request: 
-          method: get
-          uri: http://localhost:7777/foo
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Type: 
-            - text/html;charset=utf-8
-            Content-Length: 
-            - "9"
-          body: 
-            encoding: UTF-8
-            string: Hello foo
-          http_version: 
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      - request: 
-          method: get
-          uri: http://localhost:7777/bar
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Type: 
-            - text/html;charset=utf-8
-            Content-Length: 
-            - "9"
-          body: 
-            encoding: UTF-8
-            string: Hello bar
-          http_version: 
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      - request: 
-          method: get
-          uri: http://localhost:7777/bazz
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Type: 
-            - text/html;charset=utf-8
-            Content-Length: 
-            - "10"
-          body: 
-            encoding: UTF-8
-            string: Hello bazz
-          http_version: 
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      recorded_with: VCR 2.0.0
-      """
-
-    When I run `ruby make_requests.rb Goodbye`
-    Then the output should contain:
-      """
-      Hello foo
-      Hello bar
-      Hello bazz
-      """
-
-  Scenario: MultiRequest
-    Given a file named "make_requests.rb" with:
-      """ruby
-      require 'vcr_setup'
-
-      VCR.use_cassette('em_http') do
-        EventMachine.run do
-          multi = EventMachine::MultiRequest.new
-
-          %w[ foo bar bazz ].each do |path|
-            multi.add(path, EventMachine::HttpRequest.new("http://localhost:#{$server.port}/#{path}").get)
-          end
-
-          multi.callback do
-            responses = Hash[multi.responses[:callback]]
-
-            %w[ foo bar bazz ].each do |path|
-              puts responses[path].response
-            end
-
-            EventMachine.stop
-          end
-        end
-      end
-      """
-    When I run `ruby make_requests.rb Hello`
-    Then the output should contain:
-      """
-      Hello foo
-      Hello bar
-      Hello bazz
-      """
-    And the file "cassettes/em_http.yml" should contain YAML like:
-      """
-      --- 
-      http_interactions: 
-      - request: 
-          method: get
-          uri: http://localhost:7777/foo
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Type: 
-            - text/html;charset=utf-8
-            Content-Length: 
-            - "9"
-          body: 
-            encoding: UTF-8
-            string: Hello foo
-          http_version: 
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      - request: 
-          method: get
-          uri: http://localhost:7777/bar
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Type: 
-            - text/html;charset=utf-8
-            Content-Length: 
-            - "9"
-          body: 
-            encoding: UTF-8
-            string: Hello bar
-          http_version: 
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      - request: 
-          method: get
-          uri: http://localhost:7777/bazz
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Type: 
-            - text/html;charset=utf-8
-            Content-Length: 
-            - "10"
-          body: 
-            encoding: UTF-8
-            string: Hello bazz
-          http_version: 
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      recorded_with: VCR 2.0.0
-      """
-
-    When I run `ruby make_requests.rb Goodbye`
-    Then the output should contain:
-      """
-      Hello foo
-      Hello bar
-      Hello bazz
-      """
-

data/features/http_libraries/net_http.feature

@@ -1,179 +0,0 @@
-Feature: Net::HTTP
-
-  There are many ways to use Net::HTTP.  The scenarios below provide regression
-  tests for some Net::HTTP APIs that have not worked properly with VCR and
-  FakeWeb or WebMock in the past (but have since been fixed).
-
-  Background:
-    Given a file named "vcr_setup.rb" with:
-      """ruby
-      require 'ostruct'
-
-      if ARGV[0] == '--with-server'
-        $server = start_sinatra_app do
-          get('/')  { 'VCR works with Net::HTTP gets!' }
-          post('/') { 'VCR works with Net::HTTP posts!' }
-        end
-      else
-        $server = OpenStruct(:port => 0)
-      end
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.default_cassette_options = {
-          :match_requests_on => [:method, :host, :path]
-        }
-      end
-      """
-
-  Scenario Outline: Calling #post on new Net::HTTP instance
-    Given a file named "vcr_net_http.rb" with:
-      """ruby
-      require 'vcr_setup.rb'
-
-      VCR.configure do |c|
-        c.hook_into <hook_into>
-        c.cassette_library_dir = 'cassettes'
-      end
-
-      VCR.use_cassette('net_http') do
-        puts Net::HTTP.new('localhost', $server.port).post('/', '').body
-      end
-      """
-    When I run `ruby vcr_net_http.rb --with-server`
-    Then the output should contain "VCR works with Net::HTTP posts!"
-    And the file "cassettes/net_http.yml" should contain "VCR works with Net::HTTP posts!"
-
-    When I run `ruby vcr_net_http.rb`
-    Then the output should contain "VCR works with Net::HTTP posts!"
-
-    Examples:
-      | hook_into |
-      | :fakeweb  |
-      | :webmock  |
-
-  Scenario Outline: Return from yielded block
-    Given a file named "vcr_net_http.rb" with:
-      """ruby
-      require 'vcr_setup.rb'
-
-      VCR.configure do |c|
-        c.hook_into <hook_into>
-        c.cassette_library_dir = 'cassettes'
-      end
-
-      def perform_request
-        Net::HTTP.new('localhost', $server.port).request(Net::HTTP::Get.new('/', {})) do |response|
-          return response
-        end
-      end
-
-      VCR.use_cassette('net_http') do
-        puts perform_request.body
-      end
-      """
-    When I run `ruby vcr_net_http.rb --with-server`
-    Then the output should contain "VCR works with Net::HTTP gets!"
-    And the file "cassettes/net_http.yml" should contain "VCR works with Net::HTTP gets!"
-
-    When I run `ruby vcr_net_http.rb`
-    Then the output should contain "VCR works with Net::HTTP gets!"
-
-    Examples:
-      | hook_into |
-      | :fakeweb  |
-      | :webmock  |
-
-  Scenario Outline: Use Net::ReadAdapter to read body in fragments
-    Given a file named "vcr_net_http.rb" with:
-      """ruby
-      require 'vcr_setup.rb'
-
-      VCR.configure do |c|
-        c.hook_into <hook_into>
-        c.cassette_library_dir = 'cassettes'
-      end
-
-      VCR.use_cassette('net_http') do
-        body = ''
-
-        Net::HTTP.new('localhost', $server.port).request_get('/') do |response|
-          response.read_body { |frag| body << frag }
-        end
-
-        puts body
-      end
-      """
-    When I run `ruby vcr_net_http.rb --with-server`
-    Then the output should contain "VCR works with Net::HTTP gets!"
-    And the file "cassettes/net_http.yml" should contain "VCR works with Net::HTTP gets!"
-
-    When I run `ruby vcr_net_http.rb`
-    Then the output should contain "VCR works with Net::HTTP gets!"
-
-    Examples:
-      | hook_into |
-      | :fakeweb  |
-      | :webmock  |
-
-  Scenario Outline: Use open-uri (which is built on top of Net::HTTP and uses a seldom-used Net::HTTP API)
-    Given a file named "vcr_net_http.rb" with:
-      """ruby
-      require 'open-uri'
-      require 'vcr_setup.rb'
-
-      VCR.configure do |c|
-        c.hook_into <hook_into>
-        c.cassette_library_dir = 'cassettes'
-      end
-
-      VCR.use_cassette('net_http') do
-        puts open("http://localhost:#{$server.port}/").read
-      end
-      """
-    When I run `ruby vcr_net_http.rb --with-server`
-    Then the output should contain "VCR works with Net::HTTP gets!"
-    And the file "cassettes/net_http.yml" should contain "VCR works with Net::HTTP gets!"
-
-    When I run `ruby vcr_net_http.rb`
-    Then the output should contain "VCR works with Net::HTTP gets!"
-
-    Examples:
-      | hook_into |
-      | :fakeweb  |
-      | :webmock  |
-
-    Scenario Outline: Make an HTTPS request
-      Given a file named "vcr_https.rb" with:
-        """ruby
-        require 'vcr'
-
-        VCR.configure do |c|
-          c.hook_into <hook_into>
-          c.cassette_library_dir = 'cassettes'
-        end
-
-        uri = URI("https://gist.githubusercontent.com/myronmarston/fb555cb593f3349d53af/raw/6921dd638337d3f6a51b0e02e7f30e3c414f70d6/vcr_gist")
-
-        VCR.use_cassette('https') do
-          http = Net::HTTP.new(uri.host, uri.port)
-          http.use_ssl = true
-          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-          response = http.request_get(uri.path)
-
-          puts response.body
-        end
-        """
-      When I run `ruby vcr_https.rb`
-      Then the output should contain "VCR gist"
-      And the file "cassettes/https.yml" should contain "VCR gist"
-
-      When I modify the file "cassettes/https.yml" to replace "VCR gist" with "HTTPS replaying works"
-      And I run `ruby vcr_https.rb`
-      Then the output should contain "HTTPS replaying works"
-
-      Examples:
-        | hook_into |
-        | :fakeweb  |
-        | :webmock  |

data/features/middleware/faraday.feature

@@ -1,56 +0,0 @@
-Feature: Faraday middleware
-
-  VCR provides middleware that can be used with Faraday.  You can use this as
-  an alternative to Faraday's built-in test adapter.
-
-  VCR will automatically insert this middleware in the Faraday stack
-  when you configure `hook_into :faraday`. However, if you want to control
-  where the middleware goes in the faraday stack, you can use it yourself.
-  The middleware should come before the Faraday HTTP adapter.
-
-  Note that when you use the middleware directly, you don't need to configure
-  `hook_into :faraday`.
-
-  Scenario Outline: Use Faraday middleware
-    Given a file named "faraday_example.rb" with:
-      """ruby
-      request_count = 0
-      $server = start_sinatra_app do
-        get('/:path') { "Hello #{params[:path]} #{request_count += 1}" }
-      end
-
-      require 'faraday'
-      require 'vcr'
-      <extra_require>
-
-      VCR.configure do |c|
-        c.default_cassette_options = { :serialize_with => :syck }
-        c.cassette_library_dir = 'cassettes'
-      end
-
-      conn = Faraday::Connection.new(:url => "http://localhost:#{$server.port}") do |builder|
-        builder.use VCR::Middleware::Faraday
-        builder.adapter :<adapter>
-      end
-
-      VCR.use_cassette('example') do
-        puts "Response 1: #{conn.get('/foo').body}"
-      end
-
-      VCR.use_cassette('example') do
-        puts "Response 2: #{conn.get('/foo').body}"
-      end
-      """
-    When I run `ruby faraday_example.rb`
-    Then the output should contain:
-      """
-      Response 1: Hello foo 1
-      Response 2: Hello foo 1
-      """
-    And the file "cassettes/example.yml" should contain "Hello foo 1"
-
-    Examples:
-      | adapter  | extra_require                       |
-      | net_http |                                     |
-      | typhoeus | require 'typhoeus/adapters/faraday' |
-

data/features/middleware/rack.feature

@@ -1,92 +0,0 @@
-Feature: Rack
-
-  VCR provides a rack middleware that uses a cassette for the duration of
-  a request.  Simply provide `VCR::Middleware::Rack` with a block that sets
-  the cassette name and options.  You can set these based on the rack env
-  if your block accepts two arguments.
-
-  This is useful in a couple different ways:
-
-  - In a rails app, you could use this to log all HTTP API calls made by
-    the rails app (using the `:all` record mode).  Of course, this will only
-    record HTTP API calls made in the request-response cycle--API calls that
-    are offloaded to a background job will not be logged.
-  - This can be used as middleware in a simple rack HTTP proxy, to record
-    and replay the proxied requests.
-
-  Background:
-    Given a file named "remote_server.rb" with:
-      """ruby
-      request_count = 0
-      $server = start_sinatra_app do
-        get('/:path') { "Hello #{params[:path]} #{request_count += 1}" }
-      end
-      """
-    And a file named "client.rb" with:
-      """ruby
-      require 'remote_server'
-      require 'proxy_server'
-      require 'cgi'
-
-      url = URI.parse("http://localhost:#{$proxy.port}?url=#{CGI.escape("http://localhost:#{$server.port}/foo")}")
-
-      puts "Response 1: #{Net::HTTP.get_response(url).body}"
-      puts "Response 2: #{Net::HTTP.get_response(url).body}"
-      """
-    And the directory "cassettes" does not exist
-
-  Scenario: Use VCR rack middleware to record HTTP responses for a simple rack proxy app
-    Given a file named "proxy_server.rb" with:
-      """ruby
-      require 'vcr'
-
-      $proxy = start_sinatra_app do
-        use VCR::Middleware::Rack do |cassette|
-          cassette.name    'proxied'
-          cassette.options :record => :new_episodes
-        end
-
-        get('/') { Net::HTTP.get_response(URI.parse(params[:url])).body }
-      end
-
-      VCR.configure do |c|
-        c.cassette_library_dir = 'cassettes'
-        c.hook_into :webmock
-        c.allow_http_connections_when_no_cassette = true
-      end
-      """
-    When I run `ruby client.rb`
-    Then the output should contain:
-      """
-      Response 1: Hello foo 1
-      Response 2: Hello foo 1
-      """
-    And the file "cassettes/proxied.yml" should contain "Hello foo 1"
-
-  Scenario: Set cassette name based on rack request env
-    Given a file named "proxy_server.rb" with:
-      """ruby
-      require 'vcr'
-
-      $proxy = start_sinatra_app do
-        use VCR::Middleware::Rack do |cassette, env|
-          cassette.name    env['SERVER_NAME']
-        end
-
-        get('/') { Net::HTTP.get_response(URI.parse(params[:url])).body }
-      end
-
-      VCR.configure do |c|
-        c.cassette_library_dir = 'cassettes'
-        c.hook_into :webmock
-        c.allow_http_connections_when_no_cassette = true
-      end
-      """
-    When I run `ruby client.rb`
-    Then the output should contain:
-      """
-      Response 1: Hello foo 1
-      Response 2: Hello foo 1
-      """
-    And the file "cassettes/localhost.yml" should contain "Hello foo 1"
-

data/features/record_modes/all.feature

@@ -1,82 +0,0 @@
-Feature: :all
-
-  The `:all` record mode will:
-
-    - Record new interactions.
-    - Never replay previously recorded interactions.
-
-  This can be temporarily used to force VCR to re-record
-  a cassette (i.e. to ensure the responses are not out of date)
-  or can be used when you simply want to log all HTTP requests.
-
-  Background:
-    Given a file named "setup.rb" with:
-      """ruby
-      $server = start_sinatra_app do
-        get('/')    { 'Hello' }
-        get('/foo') { 'Goodbye' }
-      end
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.hook_into                :webmock
-        c.cassette_library_dir     = 'cassettes'
-      end
-      """
-    And a previously recorded cassette file "cassettes/example.yml" with:
-      """
-      --- 
-      http_interactions: 
-      - request: 
-          method: get
-          uri: http://localhost/
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Length: 
-            - "20"
-          body: 
-            encoding: UTF-8
-            string: old response
-          http_version: "1.1"
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      recorded_with: VCR 2.0.0
-      """
-
-  Scenario: Re-record previously recorded response
-    Given a file named "re_record.rb" with:
-      """ruby
-      require 'setup'
-
-      VCR.use_cassette('example', :record => :all, :match_requests_on => [:method, :host, :path]) do
-        response = Net::HTTP.get_response('localhost', '/', $server.port)
-        puts "Response: #{response.body}"
-      end
-      """
-    When I run `ruby re_record.rb`
-    Then it should pass with "Response: Hello"
-    And the file "cassettes/example.yml" should contain "Hello"
-    But the file "cassettes/example.yml" should not contain "old response"
-
-  Scenario: Record new request
-    Given a file named "record_new.rb" with:
-      """ruby
-      require 'setup'
-
-      VCR.use_cassette('example', :record => :all) do
-        response = Net::HTTP.get_response('localhost', '/foo', $server.port)
-        puts "Response: #{response.body}"
-      end
-      """
-    When I run `ruby record_new.rb`
-    Then it should pass with "Response: Goodbye"
-    And the file "cassettes/example.yml" should contain each of these:
-      | old response |
-      | Goodbye      |