vcr 2.0.0.beta1 → 2.0.0.beta2

data/features/cassettes/format.feature

@@ -1,6 +1,6 @@
 Feature: Cassette format
 
-  VCR Cassettes are YAML files that contain all of the information
+  VCR Cassettes are files that contain all of the information
   about the requests and corresponding responses in a
   human-readable/editable format.  A cassette contains an array
   of HTTP interactions, each of which has the following:
@@ -18,13 +18,43 @@ Feature: Cassette format
       - body
       - http version
 
-  Scenario Outline: Request/Response data is saved to disk as YAML
-    Given a file named "cassette_format.rb" with:
+  By default, VCR uses YAML to serialize this data.  You can configure
+  VCR to use a different serializer, either on a cassette-by-cassette
+  basis, or as a default for all cassettes if you use the `default_cassette_options`.
+
+  VCR supports the following serializers out of the box:
+
+    - `:yaml`--Uses ruby's standard library YAML. This may use psych or syck,
+      depending on your ruby installation.
+    - `:syck`--Uses syck (the ruby 1.8 YAML engine). This is useful when using
+      VCR on a project that must run in environments where psych is not available
+      (such as on ruby 1.8), to ensure that syck is always used.
+    - `:psych`--Uses psych (the new ruby 1.9 YAML engine). This is useful when
+      you want to ensure that psych is always used.
+    - `:json`--Uses [multi_json](https://github.com/intridea/multi_json)
+      to serialize the cassette data as JSON.
+
+  You can also register a custom serializer using:
+
+     VCR.configure do |config|
+       config.cassette_serializers[:my_custom_serializer] = my_serializer
+     end
+
+  Your serializer must implement the following methods:
+
+    - `file_extension`
+    - `serialize(hash)`
+    - `deserialize(string)`
+
+  Scenario Outline: Request/Response data is saved to disk as YAML by default
+    Given a file named "cassette_yaml.rb" with:
       """ruby
       include_http_adapter_for("<http_lib>")
 
-      start_sinatra_app(:port => 7777) do
-        get('/:path') { ARGV[0] + ' ' + params[:path] }
+      if ARGV.any?
+        start_sinatra_app(:port => 7777) do
+          get('/:path') { ARGV[0] + ' ' + params[:path] }
+        end
       end
 
       require 'vcr'
@@ -39,44 +69,46 @@ Feature: Cassette format
         make_http_request(:get, "http://localhost:7777/bar")
       end
       """
-    When I run `ruby cassette_format.rb 'Hello'`
+    When I run `ruby cassette_yaml.rb 'Hello'`
     Then the file "cassettes/example.yml" should contain YAML like:
       """
-      --- 
-      - !ruby/struct:VCR::HTTPInteraction 
-        request: !ruby/struct:VCR::Request 
-          method: :get
+      ---
+      http_interactions:
+      - request:
+          method: get
           uri: http://localhost:7777/foo
-          body: 
-          headers: 
-        response: !ruby/struct:VCR::Response 
-          status: !ruby/struct:VCR::ResponseStatus 
+          body: ''
+          headers: {}
+        response:
+          status:
             code: 200
             message: OK
-          headers: 
-            content-type: 
+          headers:
+            Content-Type:
             - text/html;charset=utf-8
-            content-length: 
-            - "9"
+            Content-Length:
+            - '9'
           body: Hello foo
-          http_version: "1.1"
-      - !ruby/struct:VCR::HTTPInteraction 
-        request: !ruby/struct:VCR::Request 
-          method: :get
+          http_version: '1.1'
+        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
+      - request:
+          method: get
           uri: http://localhost:7777/bar
-          body: 
-          headers: 
-        response: !ruby/struct:VCR::Response 
-          status: !ruby/struct:VCR::ResponseStatus 
+          body: ''
+          headers: {}
+        response:
+          status:
             code: 200
             message: OK
-          headers: 
-            content-type: 
+          headers:
+            Content-Type:
             - text/html;charset=utf-8
-            content-length: 
-            - "9"
+            Content-Length:
+            - '9'
           body: Hello bar
-          http_version: "1.1"
+          http_version: '1.1'
+        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
+      recorded_with: VCR 2.0.0
       """
 
     Examples:
@@ -92,3 +124,153 @@ Feature: Cassette format
       | c.hook_into :excon    | excon                 |
       |                       | faraday (w/ net_http) |
 
+  Scenario: Request/Response data can be saved as JSON
+    Given a file named "cassette_json.rb" with:
+      """ruby
+      include_http_adapter_for("net/http")
+
+      start_sinatra_app(:port => 7777) do
+        get('/:path') { ARGV[0] + ' ' + params[:path] }
+      end
+
+      require 'vcr'
+
+      VCR.configure do |c|
+        c.hook_into :webmock
+        c.cassette_library_dir = 'cassettes'
+      end
+
+      VCR.use_cassette('example', :serialize_with => :json) do
+        puts response_body_for(:get, "http://localhost:7777/foo")
+        puts response_body_for(:get, "http://localhost:7777/bar")
+      end
+      """
+    When I run `ruby cassette_json.rb 'Hello'`
+    Then the file "cassettes/example.json" should contain JSON like:
+      """json
+      {
+        "http_interactions": [
+          {
+            "response": {
+              "body": "Hello foo",
+              "http_version": null,
+              "status": { "code": 200, "message": "OK" },
+              "headers": {
+                "Date": [ "Thu, 27 Oct 2011 06:16:31 GMT" ],
+                "Content-Type": [ "text/html;charset=utf-8" ],
+                "Content-Length": [ "9" ],
+                "Server": [ "WEBrick/1.3.1 (Ruby/1.8.7/2011-06-30)" ],
+                "Connection": [ "Keep-Alive" ]
+              }
+            },
+            "request": {
+              "uri": "http://localhost:7777/foo",
+              "body": "",
+              "method": "get",
+              "headers": { }
+            },
+            "recorded_at": "Tue, 01 Nov 2011 04:58:44 GMT"
+          },
+          {
+            "response": {
+              "body": "Hello bar",
+              "http_version": null,
+              "status": { "code": 200, "message": "OK" },
+              "headers": {
+                "Date": [ "Thu, 27 Oct 2011 06:16:31 GMT" ],
+                "Content-Type": [ "text/html;charset=utf-8" ],
+                "Content-Length": [ "9" ],
+                "Server": [ "WEBrick/1.3.1 (Ruby/1.8.7/2011-06-30)" ],
+                "Connection": [ "Keep-Alive" ]
+              }
+            },
+            "request": {
+              "uri": "http://localhost:7777/bar",
+              "body": "",
+              "method": "get",
+              "headers": { }
+            },
+            "recorded_at": "Tue, 01 Nov 2011 04:58:44 GMT"
+          }
+        ],
+        "recorded_with": "VCR 2.0.0"
+      }
+      """
+    When I run `ruby cassette_json.rb`
+    Then it should pass with:
+      """
+      Hello foo
+      Hello bar
+      """
+
+  Scenario: Request/Response data can be saved using a custom serializer
+    Given a file named "cassette_ruby.rb" with:
+      """ruby
+      include_http_adapter_for("net/http")
+
+      start_sinatra_app(:port => 7777) do
+        get('/:path') { ARGV[0] + ' ' + params[:path] }
+      end
+
+      require 'vcr'
+
+      # purely for demonstration purposes; obviously, don't actually
+      # use ruby #inspect / #eval for your serialization...
+      ruby_serializer = Object.new
+      class << ruby_serializer
+        def file_extension; "ruby"; end
+        def serialize(hash); hash.inspect; end
+        def deserialize(string); eval(string); end
+      end
+
+      VCR.configure do |c|
+        c.hook_into :webmock
+        c.cassette_library_dir = 'cassettes'
+        c.cassette_serializers[:ruby] = ruby_serializer
+      end
+
+      VCR.use_cassette('example', :serialize_with => :ruby) do
+        puts response_body_for(:get, "http://localhost:7777/foo")
+        puts response_body_for(:get, "http://localhost:7777/bar")
+      end
+      """
+    When I run `ruby cassette_ruby.rb 'Hello'`
+    Then the file "cassettes/example.ruby" should contain ruby like:
+      """
+      {"http_interactions"=>
+        [{"request"=>
+           {"method"=>"get",
+            "uri"=>"http://localhost:7777/foo",
+            "body"=>"",
+            "headers"=>{"Accept"=>["*/*"], "User-Agent"=>["Ruby"]}},
+          "response"=>
+           {"status"=>{"code"=>200, "message"=>"OK "},
+            "headers"=>
+             {"Content-Type"=>["text/html;charset=utf-8"],
+              "Content-Length"=>["9"],
+              "Connection"=>["Keep-Alive"]},
+            "body"=>"Hello foo",
+            "http_version"=>nil},
+          "recorded_at"=>"Tue, 01 Nov 2011 04:58:44 GMT"},
+         {"request"=>
+           {"method"=>"get",
+            "uri"=>"http://localhost:7777/bar",
+            "body"=>"",
+            "headers"=>{"Accept"=>["*/*"], "User-Agent"=>["Ruby"]}},
+          "response"=>
+           {"status"=>{"code"=>200, "message"=>"OK "},
+            "headers"=>
+             {"Content-Type"=>["text/html;charset=utf-8"],
+              "Content-Length"=>["9"],
+              "Connection"=>["Keep-Alive"]},
+            "body"=>"Hello bar",
+            "http_version"=>nil},
+          "recorded_at"=>"Tue, 01 Nov 2011 04:58:44 GMT"}],
+       "recorded_with"=>"VCR 2.0.0"}
+      """
+    When I run `ruby cassette_ruby.rb`
+    Then it should pass with:
+      """
+      Hello foo
+      Hello bar
+      """

data/features/cassettes/update_content_length_header.feature

@@ -1,7 +1,7 @@
 Feature: Update content_length header
 
   When the `:update_content_length_header` option is set to a truthy value,
-  VCR will ensure that the `content-length` header will have the correct
+  VCR will ensure that the `Content-Length` header will have the correct
   value.  This is useful in several situations:
 
     - When you manually edit the cassette file and change the resonse body
@@ -12,33 +12,35 @@ Feature: Update content_length header
     - Syck, the default YAML engine for ruby 1.8 (and 1.9, unless you compile
       it to use Psych), has a bug where it sometimes will remove some
       whitespace strings when you serialize them.  This may cause the
-      `content-length` header to have the wrong value.
+      `Content-Length` header to have the wrong value.
 
   This is especially important when you use a client that checks the
-  `content-length` header.  Mechanize, for example, will raise an `EOFError`
+  `Content-Length` header.  Mechanize, for example, will raise an `EOFError`
   when the header value does not match the actual body length.
 
   Background:
     Given a previously recorded cassette file "cassettes/example.yml" with:
       """
-      --- 
-      - !ruby/struct:VCR::HTTPInteraction 
-        request: !ruby/struct:VCR::Request 
-          method: :get
-          uri: http://example.com:80/
-          body: 
-          headers: 
-        response: !ruby/struct:VCR::Response 
-          status: !ruby/struct:VCR::ResponseStatus 
+      ---
+      http_interactions:
+      - request:
+          method: get
+          uri: http://example.com/
+          body: ''
+          headers: {}
+        response:
+          status:
             code: 200
             message: OK
-          headers: 
-            content-type: 
+          headers:
+            Content-Type:
             - text/html;charset=utf-8
-            content-length: 
-            - "11"
+            Content-Length:
+            - '11'
           body: Hello <modified>
-          http_version: "1.1"
+          http_version: '1.1'
+        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
+      recorded_with: VCR 2.0.0
       """
     And a file named "common_stuff.rb" with:
       """ruby
@@ -52,7 +54,7 @@ Feature: Update content_length header
       def make_request_and_print_results
         response = Net::HTTP.get_response('example.com', '/')
         puts "Body length: #{response.body.length}"
-        puts "Header value: #{response['content-length']}"
+        puts "Header value: #{response['Content-Length']}"
       end
       """
 

data/features/configuration/filter_sensitive_data.feature

@@ -124,15 +124,15 @@ Feature: Filter sensitive data
         c.hook_into :webmock
         c.cassette_library_dir = 'cassettes'
         c.filter_sensitive_data('<PASSWORD>') do |interaction|
-          USER_PASSWORDS[interaction.request.headers['x-http-username'].first]
+          USER_PASSWORDS[interaction.request.headers['X-Http-Username'].first]
         end
       end
 
       VCR.use_cassette('example', :match_requests_on => [:method, :uri, :headers]) do
         puts "Response: " + response_body_for(
           :get, 'http://localhost:7777/', nil,
-          'X-HTTP-USERNAME' => 'john.doe',
-          'X-HTTP-PASSWORD' => USER_PASSWORDS['john.doe']
+          'X-Http-Username' => 'john.doe',
+          'X-Http-Password' => USER_PASSWORDS['john.doe']
         )
       end
       """
@@ -141,7 +141,7 @@ Feature: Filter sensitive data
     And the file "cassettes/example.yml" should contain "body: john.doe/<PASSWORD>"
     And the file "cassettes/example.yml" should contain a YAML fragment like:
       """
-      x-http-password:
+      X-Http-Password:
       - <PASSWORD>
       """
 

data/features/configuration/hooks.feature

@@ -39,23 +39,25 @@ Feature: Hooks
     Given a previously recorded cassette file "cassettes/example.yml" with:
       """
       ---
-      - !ruby/struct:VCR::HTTPInteraction
-        request: !ruby/struct:VCR::Request
-          method: :get
-          uri: http://example.com:80/foo
-          body:
-          headers:
-        response: !ruby/struct:VCR::Response
-          status: !ruby/struct:VCR::ResponseStatus
+      http_interactions:
+      - request:
+          method: get
+          uri: http://example.com/foo
+          body: ''
+          headers: {}
+        response:
+          status:
             code: 200
             message: OK
           headers:
-            content-type:
+            Content-Type:
             - text/html;charset=utf-8
-            content-length:
-            - "20"
+            Content-Length:
+            - '20'
           body: example.com response
-          http_version: "1.1"
+          http_version: '1.1'
+        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
+      recorded_with: VCR 2.0.0
       """
 
   Scenario: Replace sensitive data with before_record hook
@@ -135,23 +137,25 @@ Feature: Hooks
     Given a previously recorded cassette file "cassettes/localhost.yml" with:
       """
       ---
-      - !ruby/struct:VCR::HTTPInteraction
-        request: !ruby/struct:VCR::Request
-          method: :get
+      http_interactions:
+      - request:
+          method: get
           uri: http://localhost:7777/
-          body:
-          headers:
-        response: !ruby/struct:VCR::Response
-          status: !ruby/struct:VCR::ResponseStatus
+          body: ''
+          headers: {}
+        response:
+          status:
             code: 200
             message: OK
           headers:
-            content-type:
+            Content-Type:
             - text/html;charset=utf-8
-            content-length:
-            - "20"
+            Content-Length:
+            - '20'
           body: recorded response
-          http_version: "1.1"
+          http_version: '1.1'
+        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
+      recorded_with: VCR 2.0.0
       """
     And a file named "before_playback_ignore.rb" with:
       """ruby