mustwin-vcr 2.9.3

data/features/hooks/before_record.feature

@@ -0,0 +1,172 @@
+Feature: before_record hook
+
+  The `before_record` hook is called before a cassette is written to disk.
+  This can be used to modify the HTTP interaction before it is recorded.
+
+  Your block should accept up to 2 arguments.  The first argument will be
+  the HTTP interaction that is about to be written to disk.  The second
+  argument will be the current cassette.
+
+  If you wish to prevent VCR from recording the HTTP interaction you can call
+  `#ignore!` on the interaction.
+
+  If you don't want your hook to apply to all cassettes, you can use tags to
+  select which cassettes a given hook applies to.  Consider this code:
+
+      VCR.configure do |c|
+        c.before_record(:twitter) { ... } # modify the interactions somehow
+      end
+
+      VCR.use_cassette('cassette_1', :tag => :twitter) { ... }
+      VCR.use_cassette('cassette_2') { ... }
+
+  In this example, the hook would apply to the first cassette but not the
+  second cassette.
+
+  Scenario: Modify recorded response
+    Given a file named "before_record_example.rb" with:
+      """ruby
+      $server = start_sinatra_app do
+        get('/') { "Hello Earth" }
+      end
+
+      require 'vcr'
+
+      VCR.configure do |c|
+        c.hook_into :webmock
+        c.cassette_library_dir = 'cassettes'
+
+        c.before_record do |i|
+          i.response.body.sub!('Earth', 'World')
+        end
+      end
+
+      VCR.use_cassette('recording_example') do
+        Net::HTTP.get_response('localhost', '/', $server.port)
+      end
+      """
+    When I run `ruby before_record_example.rb`
+    Then the file "cassettes/recording_example.yml" should contain "Hello World"
+     And the file "cassettes/recording_example.yml" should not contain "Earth"
+
+  Scenario: Modify recorded response based on the cassette
+    Given a file named "before_record_example.rb" with:
+      """ruby
+      $server = start_sinatra_app do
+        get('/') { "Hello Earth" }
+      end
+
+      require 'vcr'
+
+      VCR.configure do |c|
+        c.hook_into :webmock
+        c.cassette_library_dir = 'cassettes'
+
+        c.before_record do |interaction, cassette|
+          interaction.response.body << " (#{cassette.name})"
+        end
+      end
+
+      VCR.use_cassette('recording_example') do
+        Net::HTTP.get_response('localhost', '/', $server.port)
+      end
+      """
+    When I run `ruby before_record_example.rb`
+    Then the file "cassettes/recording_example.yml" should contain "Hello Earth (recording_example)"
+
+  Scenario: Prevent recording by ignoring interaction in before_record hook
+    Given a file named "before_record_ignore.rb" with:
+      """ruby
+      $server = start_sinatra_app do
+        get('/') { "Hello World" }
+      end
+
+      require 'vcr'
+
+      VCR.configure do |c|
+        c.hook_into :webmock
+        c.cassette_library_dir = 'cassettes'
+        c.before_record { |i| i.ignore! }
+      end
+
+      VCR.use_cassette('recording_example') do
+        response = Net::HTTP.get_response('localhost', '/', $server.port)
+        puts "Response: #{response.body}"
+      end
+      """
+    When I run `ruby before_record_ignore.rb`
+    Then it should pass with "Response: Hello World"
+    And the file "cassettes/recording_example.yml" should not exist
+
+  Scenario: Multiple hooks are run in order
+    Given a file named "multiple_hooks.rb" with:
+      """ruby
+      $server = start_sinatra_app do
+        get('/') { "Hello World" }
+      end
+
+      require 'vcr'
+
+      VCR.configure do |c|
+        c.hook_into :webmock
+        c.cassette_library_dir = 'cassettes'
+
+        c.before_record { puts "In before_record hook 1" }
+        c.before_record { puts "In before_record hook 2" }
+      end
+
+      VCR.use_cassette('example', :record => :new_episodes) do
+        response = Net::HTTP.get_response('localhost', '/', $server.port)
+        puts "Response: #{response.body}"
+      end
+      """
+    When I run `ruby multiple_hooks.rb`
+    Then it should pass with:
+      """
+      Response: Hello World
+      In before_record hook 1
+      In before_record hook 2
+      """
+
+  Scenario: Use tagging to apply hook to only certain cassettes
+    Given a file named "tagged_hooks.rb" with:
+      """ruby
+      $server = start_sinatra_app do
+        get('/') { "Hello World" }
+      end
+
+      require 'vcr'
+
+      VCR.configure do |c|
+        c.hook_into :webmock
+        c.cassette_library_dir = 'cassettes'
+
+        c.before_record(:tag_1) do
+          puts "In before_record hook for tag_1"
+        end
+      end
+
+      [:tag_1, :tag_2, nil].each do |tag|
+        puts
+        puts "Using tag: #{tag.inspect}"
+
+        VCR.use_cassette('example', :record => :new_episodes, :tag => tag) do
+          response = Net::HTTP.get_response('localhost', '/', $server.port)
+          puts "Response: #{response.body}"
+        end
+      end
+      """
+    When I run `ruby tagged_hooks.rb`
+    Then it should pass with:
+      """
+      Using tag: :tag_1
+      Response: Hello World
+      In before_record hook for tag_1
+
+      Using tag: :tag_2
+      Response: Hello World
+
+      Using tag: nil
+      Response: Hello World
+      """
+

data/features/http_libraries/em_http_request.feature

@@ -0,0 +1,250 @@
+@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

@@ -0,0 +1,179 @@
+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  |