vcr 2.1.1 → 2.2.0

data/lib/vcr/middleware/faraday.rb

@@ -17,7 +17,7 @@ module VCR
 
       # Constructs a new instance of the Faraday middleware.
       #
-      # @param [#call] the faraday app
+      # @param [#call] app the faraday app
       def initialize(app)
         super
         @app = app
@@ -57,10 +57,18 @@ module VCR
           @vcr_request ||= VCR::Request.new \
             env[:method],
             env[:url].to_s,
-            env[:body],
+            raw_body_from(env[:body]),
             env[:request_headers]
         end
 
+        def raw_body_from(body)
+          return body unless body.respond_to?(:read)
+
+          body.read.tap do |b|
+            body.rewind if body.respond_to?(:rewind)
+          end
+        end
+
         def response_for(env)
           response = env[:response]
           return nil unless response
@@ -68,7 +76,7 @@ module VCR
           VCR::Response.new(
             VCR::ResponseStatus.new(response.status, nil),
             response.headers,
-            response.body,
+            raw_body_from(response.body),
             nil
           )
         end
@@ -77,7 +85,7 @@ module VCR
           app.call(env)
         end
 
-        def on_stubbed_request
+        def on_stubbed_by_vcr_request
           headers = env[:response_headers] ||= ::Faraday::Utils::Headers.new
           headers.update stubbed_response.headers if stubbed_response.headers
           env.update :status => stubbed_response.status.code, :body => stubbed_response.body

data/lib/vcr/request_handler.rb

@@ -32,8 +32,9 @@ module VCR
 
     def request_type(consume_stub = false)
       case
+        when externally_stubbed?                then :externally_stubbed
         when should_ignore?                     then :ignored
-        when has_response_stub?(consume_stub)   then :stubbed
+        when has_response_stub?(consume_stub)   then :stubbed_by_vcr
         when VCR.real_http_connections_allowed? then :recordable
         else                                         :unhandled
       end
@@ -50,6 +51,10 @@ module VCR
       VCR.configuration.invoke_hook(:after_http_request, @after_hook_typed_request, vcr_response)
     end
 
+    def externally_stubbed?
+      false
+    end
+
     def should_ignore?
       disabled? || VCR.request_ignorer.ignore?(vcr_request)
     end
@@ -76,10 +81,13 @@ module VCR
     end
 
     # Subclasses can implement these
+    def on_externally_stubbed_request
+    end
+
     def on_ignored_request
     end
 
-    def on_stubbed_request
+    def on_stubbed_by_vcr_request
     end
 
     def on_recordable_request

data/lib/vcr/structs.rb

@@ -60,6 +60,11 @@ module VCR
 
       def initialize(*args)
         super
+
+        if body && !body.is_a?(String)
+          raise ArgumentError, "#{self.class} initialized with an invalid body: #{body.inspect}."
+        end
+
         # Ensure that the body is a raw string, in case the string instance
         # has been subclassed or extended with additional instance variables
         # or attributes, so that it is serialized to YAML as a raw string.
@@ -109,7 +114,7 @@ module VCR
             else [v]
           end
 
-          new_headers[k] = convert_to_raw_strings(val_array)
+          new_headers[String.new(k)] = convert_to_raw_strings(val_array)
           @normalized_header_keys[k.downcase] = k
         end if headers
 
@@ -249,9 +254,19 @@ module VCR
         type == :ignored
       end
 
-      # @return [Boolean] whether or not this request will be stubbed
-      def stubbed?
-        type == :stubbed
+      # @return [Boolean] whether or not this request is being stubbed by VCR
+      # @see #externally_stubbed?
+      # @see #stubbed?
+      def stubbed_by_vcr?
+        type == :stubbed_by_vcr
+      end
+
+      # @return [Boolean] whether or not this request is being stubbed by an
+      #  external library (such as WebMock or FakeWeb).
+      # @see #stubbed_by_vcr?
+      # @see #stubbed?
+      def externally_stubbed?
+        type == :externally_stubbed
       end
 
       # @return [Boolean] whether or not this request will be recorded.
@@ -270,6 +285,14 @@ module VCR
         ignored? || recordable?
       end
 
+      # @return [Boolean] whether or not this request will be stubbed.
+      #  It may be stubbed by an external library or by VCR.
+      # @see #stubbed_by_vcr?
+      # @see #externally_stubbed?
+      def stubbed?
+        stubbed_by_vcr? || externally_stubbed?
+      end
+
       undef method
     end
 
@@ -497,10 +520,11 @@ module VCR
       # Replaces a string in any part of the HTTP interaction (headers, request body,
       # response body, etc) with the given replacement text.
       #
-      # @param [String] text the text to replace
-      # @param [String] replacement_text the text to put in its place
+      # @param [#to_s] text the text to replace
+      # @param [#to_s] replacement_text the text to put in its place
       def filter!(text, replacement_text)
-        return self if [text, replacement_text].any? { |t| t.to_s.empty? }
+        text, replacement_text = text.to_s, replacement_text.to_s
+        return self if [text, replacement_text].any? { |t| t.empty? }
         filter_object!(self, text, replacement_text)
       end
 

data/lib/vcr/version.rb

@@ -10,7 +10,7 @@ module VCR
   #   * `parts` [Array<Integer>] List of the version parts.
   def version
     @version ||= begin
-      string = '2.1.1'
+      string = '2.2.0'
 
       def string.parts
         split('.').map { |p| p.to_i }

data/script/ci.sh

@@ -0,0 +1,14 @@
+# Kill the whole script on error
+set -e
+
+# Setup vendored rspec-1
+git submodule init
+git submodule update
+
+bundle exec ruby -w -I./spec -r./spec/capture_warnings -rspec_helper -S rspec spec --format progress --backtrace
+
+bundle exec cucumber
+
+bundle exec rake yard_coverage
+
+bundle exec rake check_code_coverage

data/spec/spec_helper.rb

@@ -28,7 +28,14 @@ end
 
 require 'rspec'
 
-Dir['./spec/support/**/*.rb'].each { |f| require f }
+require "support/fixnum_extension.rb"
+require "support/http_library_adapters.rb"
+require "support/ruby_interpreter.rb"
+require "support/shared_example_groups/hook_into_http_library.rb"
+require "support/shared_example_groups/request_hooks.rb"
+require "support/sinatra_app.rb"
+require "support/vcr_localhost_server.rb"
+require "support/vcr_stub_helpers.rb"
 
 require 'vcr'
 require 'monkey_patches'

data/spec/support/shared_example_groups/hook_into_http_library.rb

@@ -144,6 +144,28 @@ shared_examples_for "a hook into an HTTP library" do |library_hook_name, library
           directly_stub_request(:get, request_url, "stubbed response")
           get_body_string(make_http_request(:get, request_url)).should eq("stubbed response")
         end
+
+        it 'can directly stub the request when VCR is turned on and no cassette is in use' do
+          directly_stub_request(:get, request_url, "stubbed response")
+          get_body_string(make_http_request(:get, request_url)).should eq("stubbed response")
+        end
+
+        it 'can directly stub the request when VCR is turned on and a cassette is in use' do
+          VCR.use_cassette("temp") do
+            directly_stub_request(:get, request_url, "stubbed response")
+            get_body_string(make_http_request(:get, request_url)).should eq("stubbed response")
+          end
+        end
+
+        it 'does not record requests that are directly stubbed' do
+          VCR.should respond_to(:record_http_interaction)
+          VCR.should_not_receive(:record_http_interaction)
+
+          VCR.use_cassette("temp") do
+            directly_stub_request(:get, request_url, "stubbed response")
+            get_body_string(make_http_request(:get, request_url)).should eq("stubbed response")
+          end
+        end
       end
     end
 
@@ -306,6 +328,14 @@ shared_examples_for "a hook into an HTTP library" do |library_hook_name, library
         it_behaves_like "request hooks", library_hook_name, :ignored
       end
 
+      context "when the request is directly stubbed" do
+        before(:each) do
+          directly_stub_request(:get, request_url, "FOO!")
+        end
+
+        it_behaves_like "request hooks", library_hook_name, :externally_stubbed
+      end if method_defined?(:directly_stub_request)
+
       context 'when the request is recorded' do
         let!(:inserted_cassette) { VCR.insert_cassette('new_cassette') }
 
@@ -341,7 +371,7 @@ shared_examples_for "a hook into an HTTP library" do |library_hook_name, library
           stub_requests([http_interaction(request_url)], [:method, :uri])
         end
 
-        it_behaves_like "request hooks", library_hook_name, :stubbed
+        it_behaves_like "request hooks", library_hook_name, :stubbed_by_vcr
       end
 
       context 'when the request is not allowed' do

data/spec/vcr/cassette/{reader_spec.rb → erb_renderer_spec.rb}

@@ -1,54 +1,48 @@
 require 'spec_helper'
 
-describe VCR::Cassette::Reader do
-  describe '#read' do
-    def read(*args)
-      described_class.new(*args).read
+describe VCR::Cassette::ERBRenderer do
+  describe '#render' do
+    def render(*args)
+      described_class.new(*args).render
     end
 
     let(:no_vars_content) { '<%= 3 + 4 %>. Some ERB' }
     let(:vars_content) { '<%= var1 %>. ERB with Vars! <%= var2 %>' }
 
-    before(:each) do
-      File.stub(:read) do |name|
-        case name
-          when 'no_vars'; no_vars_content
-          when 'vars'; vars_content
-          else raise ArgumentError.new("Unexpected file name: #{name}")
-        end
-      end
-    end
-
     context 'when ERB is disabled' do
-      it 'reads the raw file content' do
-        read('no_vars', false).should eq(no_vars_content)
-        read('no_vars', nil).should eq(no_vars_content)
+      it 'returns the given template' do
+        render(no_vars_content, false).should eq(no_vars_content)
+        render(no_vars_content, nil).should eq(no_vars_content)
       end
     end
 
     context 'when ERB is enabled but no variables are passed' do
       it 'renders the file content as ERB' do
-        read('no_vars', true).should eq("7. Some ERB")
+        render(no_vars_content, true).should eq("7. Some ERB")
       end
 
       it 'raises an appropriate error when the ERB template needs variables' do
         expect {
-          read('vars', true)
+          render(vars_content, true, "vars")
         }.to raise_error(VCR::Errors::MissingERBVariableError,
           %{The ERB in the vars cassette file references undefined variable var1.  } +
           %{Pass it to the cassette using :erb => #{ {:var1=>"some value"}.inspect }.}
         )
       end
+
+      it 'gracefully handles the template being nil' do
+        render(nil, true).should be_nil
+      end
     end
 
     context 'when ERB is enabled and variables are passed' do
       it 'renders the file content as ERB with the passed variables' do
-        read('vars', :var1 => 'foo', :var2 => 'bar').should eq('foo. ERB with Vars! bar')
+        render(vars_content, :var1 => 'foo', :var2 => 'bar').should eq('foo. ERB with Vars! bar')
       end
 
       it 'raises an appropriate error when one or more of the needed variables are not passed' do
         expect {
-          read('vars', :var1 => 'foo')
+          render(vars_content, { :var1 => 'foo' }, "vars")
         }.to raise_error(VCR::Errors::MissingERBVariableError,
           %{The ERB in the vars cassette file references undefined variable var2.  } +
           %{Pass it to the cassette using :erb => #{ {:var1 => "foo", :var2 => "some value"}.inspect }.}

data/spec/vcr/cassette/http_interaction_list_spec.rb

@@ -86,6 +86,21 @@ module VCR
         end
       end
 
+      describe "#assert_no_unused_interactions?" do
+        it 'should raise a SkippedHTTPRequestError when there are unused interactions left' do
+           expect { list.assert_no_unused_interactions! }.to raise_error(Errors::UnusedHTTPInteractionError)
+           list.response_for(request_with(:method => :put))
+           expect { list.assert_no_unused_interactions! }.to raise_error(Errors::UnusedHTTPInteractionError)
+        end
+
+        it 'should raise nothing when there are no unused interactions left' do
+          [:put, :post, :post].each do |method|
+            list.response_for(request_with(:method => method))
+          end
+          list.assert_no_unused_interactions! # should not raise an error.
+        end
+      end
+
       describe "has_interaction_matching?" do
         it 'returns false when the list is empty' do
           HTTPInteractionList.new([], [:method]).should_not have_interaction_matching(stub)

data/spec/vcr/cassette/persisters/file_system_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+require 'vcr/cassette/persisters/file_system'
+
+module VCR
+  class Cassette
+    class Persisters
+      describe FileSystem do
+        before { FileSystem.storage_location = VCR.configuration.cassette_library_dir }
+
+        describe "#[]" do
+          it 'reads from the given file, relative to the configured storage location' do
+            File.open(FileSystem.storage_location + '/foo.txt', 'w') { |f| f.write('1234') }
+            FileSystem["foo.txt"].should eq("1234")
+          end
+
+          it 'handles directories in the given file name' do
+            FileUtils.mkdir_p FileSystem.storage_location + '/a'
+            File.open(FileSystem.storage_location + '/a/b', 'w') { |f| f.write('1234') }
+            FileSystem["a/b"].should eq("1234")
+          end
+
+          it 'returns nil if the file does not exist' do
+            FileSystem["non_existant_file"].should be_nil
+          end
+        end
+
+        describe "#[]=" do
+          it 'writes the given file contents to the given file name' do
+            File.exist?(FileSystem.storage_location + '/foo.txt').should be_false
+            FileSystem["foo.txt"] = "bar"
+            File.read(FileSystem.storage_location + '/foo.txt').should eq("bar")
+          end
+
+          it 'creates any needed intermediary directories' do
+            File.exist?(FileSystem.storage_location + '/a').should be_false
+            FileSystem["a/b"] = "bar"
+            File.read(FileSystem.storage_location + '/a/b').should eq("bar")
+          end
+        end
+
+        describe "#absolute_path_to_file" do
+          it "returns the absolute path to the given relative file based on the storage location" do
+            expected = File.join(FileSystem.storage_location, "bar/bazz.json")
+            FileSystem.absolute_path_to_file("bar/bazz.json").should eq(expected)
+          end
+
+          it "returns nil if the storage_location is not set" do
+            FileSystem.storage_location = nil
+            FileSystem.absolute_path_to_file("bar/bazz.json").should be_nil
+          end
+
+          it "sanitizes the file name" do
+            expected = File.join(FileSystem.storage_location, "_t_i-t_1_2_f_n.json")
+            FileSystem.absolute_path_to_file("\nt \t!  i-t_1.2_f n.json").should eq(expected)
+
+            expected = File.join(FileSystem.storage_location, "a_1/b")
+            FileSystem.absolute_path_to_file("a 1/b").should eq(expected)
+          end
+        end
+      end
+    end
+  end
+end
+

data/spec/vcr/cassette/persisters_spec.rb

@@ -0,0 +1,39 @@
+require 'vcr/cassette/persisters'
+
+module VCR
+  class Cassette
+    describe Persisters do
+      describe "#[]=" do
+        context 'when there is already a persister registered for the given name' do
+          before(:each) do
+            subject[:foo] = :old_persister
+            subject.stub :warn
+          end
+
+          it 'overrides the existing persister' do
+            subject[:foo] = :new_persister
+            subject[:foo].should be(:new_persister)
+          end
+
+          it 'warns that there is a name collision' do
+            subject.should_receive(:warn).with(
+              /WARNING: There is already a VCR cassette persister registered for :foo\. Overriding it/
+            )
+            subject[:foo] = :new_persister
+          end
+        end
+      end
+
+      describe "#[]" do
+        it 'raises an error when given an unrecognized persister name' do
+          expect { subject[:foo] }.to raise_error(ArgumentError)
+        end
+
+        it 'returns the named persister' do
+          subject[:file_system].should be(VCR::Cassette::Persisters::FileSystem)
+        end
+      end
+    end
+  end
+end
+