vcr 3.0.3 → 6.1.0

data/spec/lib/vcr/cassette/http_interaction_list_spec.rb

@@ -1,295 +0,0 @@
-require 'vcr/util/logger'
-require 'vcr/cassette/http_interaction_list'
-require 'vcr/request_matcher_registry'
-require 'vcr/structs'
-require 'support/configuration_stubbing'
-
-module VCR
-  class Cassette
-    describe HTTPInteractionList do
-      include_context "configuration stubbing"
-
-      ::RSpec::Matchers.define :respond_with do |expected|
-        match { |a| expected.nil? ? a.nil? : a.body == expected }
-      end
-
-      before(:each) do
-        allow(VCR).to receive(:request_matchers).and_return(VCR::RequestMatcherRegistry.new)
-        allow(config).to receive(:logger).and_return(double.as_null_object)
-      end
-
-      def request_with(values)
-        VCR::Request.new.tap do |request|
-          values.each do |name, value|
-            request.send("#{name}=", value)
-          end
-        end
-      end
-
-      def response(body)
-        VCR::Response.new.tap do |r|
-          r.body = body
-          r.status = VCR::ResponseStatus.new(200)
-        end
-      end
-
-      def interaction(body, request_values)
-        VCR::HTTPInteraction.new \
-          request_with(request_values),
-          response(body)
-      end
-
-      let(:original_list_array) do [
-        interaction('put response', :method => :put),
-        interaction('post response 1', :method => :post),
-        interaction('post response 2', :method => :post)
-      ] end
-
-      let(:allow_playback_repeats) { false } # the default
-      let(:list) { HTTPInteractionList.new(original_list_array, [:method], allow_playback_repeats) }
-
-      describe "#has_used_interaction_matching?" do
-        it 'returns false when no interactions have been used' do
-          expect(list).not_to have_used_interaction_matching(request_with(:method => :put))
-        end
-
-        it 'returns true when there is a matching used interaction (even if there is also an unused one that matches)' do
-          list.response_for(request_with(:method => :post))
-          expect(list).to have_used_interaction_matching(request_with(:method => :post))
-        end
-
-        it 'returns false when none of the used interactions match' do
-          list.response_for(request_with(:method => :put))
-          expect(list).not_to have_used_interaction_matching(request_with(:method => :post))
-        end
-      end
-
-      describe "#remaining_unused_interaction_count" do
-        it 'returns the number of unused interactions' do
-          expect(list.remaining_unused_interaction_count).to eq(3)
-
-          list.response_for(request_with(:method => :get))
-          expect(list.remaining_unused_interaction_count).to eq(3)
-
-          list.response_for(request_with(:method => :put))
-          expect(list.remaining_unused_interaction_count).to eq(2)
-
-          list.response_for(request_with(:method => :put))
-          expect(list.remaining_unused_interaction_count).to eq(2)
-
-          list.response_for(request_with(:method => :post))
-          expect(list.remaining_unused_interaction_count).to eq(1)
-
-          list.response_for(request_with(:method => :post))
-          expect(list.remaining_unused_interaction_count).to eq(0)
-
-          list.response_for(request_with(:method => :post))
-          expect(list.remaining_unused_interaction_count).to eq(0)
-        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
-
-          expect {
-            list.assert_no_unused_interactions!
-          }.not_to raise_error
-        end
-
-        context 'when the null logger is in use' do
-          before { allow(config).to receive(:logger).and_return(Logger::Null) }
-
-          it 'includes formatted request details in the error message' do
-            expect {
-              list.assert_no_unused_interactions!
-            }.to raise_error(/\[put/)
-          end
-
-          it 'includes formatted response details in the error message' do
-            expect {
-              list.assert_no_unused_interactions!
-            }.to raise_error(/\[200 "put response"\]/)
-          end
-        end
-      end
-
-      describe "has_interaction_matching?" do
-        it 'returns false when the list is empty' do
-          expect(HTTPInteractionList.new([], [:method])).not_to have_interaction_matching(double)
-        end
-
-        it 'returns false when there is no matching interaction' do
-          expect(list).not_to have_interaction_matching(request_with(:method => :get))
-        end
-
-        it 'returns true when there is a matching interaction' do
-          expect(list).to have_interaction_matching(request_with(:method => :post))
-        end
-
-        it 'does not consume the interactions when they match' do
-          expect(list).to have_interaction_matching(request_with(:method => :post))
-          expect(list.remaining_unused_interaction_count).to eq(3)
-          expect(list).to have_interaction_matching(request_with(:method => :post))
-          expect(list.remaining_unused_interaction_count).to eq(3)
-        end
-
-        it 'invokes each matcher block to find the matching interaction' do
-          VCR.request_matchers.register(:foo) { |r1, r2| true }
-          VCR.request_matchers.register(:bar) { |r1, r2| true }
-
-          calls = 0
-          VCR.request_matchers.register(:baz) { |r1, r2| calls += 1; calls == 2 }
-
-          list = HTTPInteractionList.new([
-            interaction('response', :method => :put)
-          ], [:foo, :bar, :baz])
-
-          expect(list).not_to have_interaction_matching(request_with(:method => :post))
-          expect(list).to     have_interaction_matching(request_with(:method => :post))
-        end
-
-        it "delegates to the parent list when it can't find a matching interaction" do
-          parent_list = double(:has_interaction_matching? => true)
-          expect(HTTPInteractionList.new( [], [:method], false, parent_list)).to have_interaction_matching(double)
-          parent_list = double(:has_interaction_matching? => false)
-          expect(HTTPInteractionList.new( [], [:method], false, parent_list)).not_to have_interaction_matching(double)
-        end
-
-        context 'when allow_playback_repeats is set to true' do
-          let(:allow_playback_repeats) { true }
-
-          it 'considers used interactions' do
-            list.response_for(request_with(:method => :put))
-
-            results = 10.times.map do
-              list.has_interaction_matching?(request_with(:method => :put))
-            end
-
-            expect(results).to eq([true] * 10)
-          end
-        end
-
-        context 'when allow_playback_repeats is set to false' do
-          let(:allow_playback_repeats) { false }
-
-          it 'does not consider used interactions' do
-            list.response_for(request_with(:method => :put))
-
-            result = 10.times.map do
-              list.has_interaction_matching?(request_with(:method => :put))
-            end
-
-            expect(result).to eq([false] * 10)
-          end
-        end
-      end
-
-      describe "#response_for" do
-        it 'returns nil when the list is empty' do
-          expect(HTTPInteractionList.new([], [:method]).response_for(double)).to respond_with(nil)
-        end
-
-        it 'returns nil when there is no matching interaction' do
-          response = HTTPInteractionList.new([
-            interaction('foo', :method => :post),
-            interaction('foo', :method => :put)
-          ], [:method]).response_for(
-            request_with(:method => :get)
-          )
-
-          expect(response).to respond_with(nil)
-        end
-
-        it 'returns the first matching interaction' do
-          list = HTTPInteractionList.new([
-            interaction('put response', :method => :put),
-            interaction('post response 1', :method => :post),
-            interaction('post response 2', :method => :post)
-          ], [:method])
-
-          expect(list.response_for(request_with(:method => :post))).to respond_with("post response 1")
-        end
-
-        it 'invokes each matcher block to find the matching interaction' do
-          VCR.request_matchers.register(:foo) { |r1, r2| true }
-          VCR.request_matchers.register(:bar) { |r1, r2| true }
-
-          calls = 0
-          VCR.request_matchers.register(:baz) { |r1, r2| calls += 1; calls == 2 }
-
-          list = HTTPInteractionList.new([
-            interaction('response', :method => :put)
-          ], [:foo, :bar, :baz])
-
-          expect(list.response_for(request_with(:method => :post))).to respond_with(nil)
-          expect(list.response_for(request_with(:method => :post))).to respond_with('response')
-        end
-
-        it "delegates to the parent list when it can't find a matching interaction" do
-          parent_list = double(:response_for => response('parent'))
-          result = HTTPInteractionList.new(
-            [], [:method], false, parent_list
-          ).response_for(double)
-
-          expect(result).to respond_with('parent')
-        end
-
-        it 'consumes the first matching interaction so that it will not be used again' do
-          expect(list.response_for(request_with(:method => :post)).body).to eq("post response 1")
-          expect(list.response_for(request_with(:method => :post)).body).to eq("post response 2")
-        end
-
-        context 'when allow_playback_repeats is set to true' do
-          let(:allow_playback_repeats) { true }
-
-          it 'continues to return the response from the last matching interaction when there are no more' do
-            list.response_for(request_with(:method => :post))
-
-            results = 10.times.map do
-              response = list.response_for(request_with(:method => :post))
-              response ? response.body : nil
-            end
-
-            expect(results).to eq(["post response 2"] * 10)
-          end
-        end
-
-        context 'when allow_playback_repeats is set to false' do
-          let(:allow_playback_repeats) { false }
-
-          it 'returns nil when there are no more unused interactions' do
-            list.response_for(request_with(:method => :post))
-            list.response_for(request_with(:method => :post))
-
-            results = 10.times.map do
-              list.response_for(request_with(:method => :post))
-            end
-
-            expect(results).to eq([nil] * 10)
-          end
-        end
-
-        it 'does not modify the original interaction array the list was initialized with' do
-          original_dup = original_list_array.dup
-          list.response_for(request_with(:method => :post))
-          expect(original_list_array).to eq original_dup
-        end
-      end
-    end
-  end
-end
-

data/spec/lib/vcr/cassette/migrator_spec.rb

@@ -1,196 +0,0 @@
-require 'tmpdir'
-require 'vcr/cassette/migrator'
-require 'yaml'
-
-describe VCR::Cassette::Migrator do
-  let(:original_contents) { <<-EOF
----
-- !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
-      code: 200
-      message: OK
-    headers:
-      content-type:
-      - text/html;charset=utf-8
-      content-length:
-      - "9"
-    body: Hello foo
-    http_version: "1.1"
-- !ruby/struct:VCR::HTTPInteraction
-  request: !ruby/struct:VCR::Request
-    method: :get
-    uri: http://localhost:7777/bar
-    body:
-    headers:
-  response: !ruby/struct:VCR::Response
-    status: !ruby/struct:VCR::ResponseStatus
-      code: 200
-      message: OK
-    headers:
-      content-type:
-      - text/html;charset=utf-8
-      content-length:
-      - "9"
-    body: Hello bar
-    http_version: "1.1"
-EOF
-  }
-
-  let(:updated_contents) { <<-EOF
----
-http_interactions:
-- request:
-    method: get
-    uri: http://example.com/foo
-    body:
-      encoding: US-ASCII
-      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: "1.1"
-  recorded_at: Wed, 04 May 2011 12:30:00 GMT
-- request:
-    method: get
-    uri: http://localhost:7777/bar
-    body:
-      encoding: US-ASCII
-      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: "1.1"
-  recorded_at: Wed, 04 May 2011 12:30:00 GMT
-recorded_with: VCR #{VCR.version}
-EOF
-  }
-
-  let(:dir) { './tmp/migrator' }
-
-  before(:each) do
-    # ensure the directory is empty
-    FileUtils.rm_rf dir
-    FileUtils.mkdir_p dir
-  end
-
-  before(:each) do
-    # the encoding won't be set on rubies that don't support it
-    updated_contents.gsub!(/^\s+encoding:.*$/, '')
-  end unless ''.respond_to?(:encoding)
-
-  # JRuby serializes YAML with some slightly different whitespace.
-  before(:each) do
-    [original_contents, updated_contents].each do |contents|
-      contents.gsub!(/^(\s+)-/, '\1  -')
-    end
-    updated_contents.gsub!(/^(- |  )/, '  \1')
-  end if RUBY_PLATFORM == 'java'
-
-  # Use syck on all rubies for consistent results...
-  around(:each) do |example|
-    YAML::ENGINE.yamler = 'syck'
-    begin
-      example.call
-    ensure
-      YAML::ENGINE.yamler = 'psych'
-    end
-  end if defined?(YAML::ENGINE) && RUBY_VERSION.to_f < 2.0
-
-  let(:filemtime) { Time.utc(2011, 5, 4, 12, 30) }
-  let(:out_io)    { StringIO.new }
-  let(:file_name) { File.join(dir, "example.yml") }
-  let(:output)    { out_io.rewind; out_io.read }
-
-  subject { described_class.new(dir, out_io) }
-
-  before(:each) do
-    allow(File).to receive(:mtime).with(file_name).and_return(filemtime)
-  end
-
-  it 'migrates a cassette from the 1.x to 2.x format' do
-    File.open(file_name, 'w') { |f| f.write(original_contents) }
-    subject.migrate!
-    expect(YAML.load_file(file_name)).to eq(YAML.load(updated_contents))
-    expect(output).to match(/Migrated example.yml/)
-  end
-
-  it 'ignores files that do not contain arrays' do
-    File.open(file_name, 'w') { |f| f.write(true.to_yaml) }
-    subject.migrate!
-    expect(File.read(file_name)).to eq(true.to_yaml)
-    expect(output).to match(/Ignored example.yml since it does not appear to be a valid VCR 1.x cassette/)
-  end
-
-  it 'ignores files that contain YAML arrays of other things' do
-    File.open(file_name, 'w') { |f| f.write([{}, {}].to_yaml) }
-    subject.migrate!
-    expect(File.read(file_name)).to eq([{}, {}].to_yaml)
-    expect(output).to match(/Ignored example.yml since it does not appear to be a valid VCR 1.x cassette/)
-  end
-
-  it 'ignores URIs that have sensitive data substitutions' do
-    modified_contents = original_contents.gsub('example.com', '<HOST>')
-    File.open(file_name, 'w') { |f| f.write(modified_contents) }
-    subject.migrate!
-    expect(YAML.load_file(file_name)).to eq(YAML.load(updated_contents.gsub('example.com', '<HOST>:80')))
-  end
-
-  it 'ignores files that are empty' do
-    File.open(file_name, 'w') { |f| f.write('') }
-    subject.migrate!
-    expect(File.read(file_name)).to eq('')
-    expect(output).to match(/Ignored example.yml since it could not be parsed as YAML/)
-  end
-
-  shared_examples_for "ignoring invalid YAML" do
-    it 'ignores files that cannot be parsed as valid YAML (such as ERB cassettes)' do
-      modified_contents = original_contents.gsub(/\A---/, "---\n<% 3.times do %>")
-      modified_contents = modified_contents.gsub(/\z/, "<% end %>")
-      File.open(file_name, 'w') { |f| f.write(modified_contents) }
-      subject.migrate!
-      expect(File.read(file_name)).to eq(modified_contents)
-      expect(output).to match(/Ignored example.yml since it could not be parsed as YAML/)
-    end
-  end
-
-  context 'with syck' do
-    it_behaves_like "ignoring invalid YAML"
-  end
-
-  context 'with psych' do
-    before(:each) do
-      YAML::ENGINE.yamler = 'psych'
-    end
-
-    it_behaves_like "ignoring invalid YAML"
-  end if defined?(YAML::ENGINE)
-end
-

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

@@ -1,75 +0,0 @@
-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') }
-            expect(FileSystem["foo.txt"]).to 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') }
-            expect(FileSystem["a/b"]).to eq("1234")
-          end
-
-          it 'returns nil if the file does not exist' do
-            expect(FileSystem["non_existant_file"]).to be_nil
-          end
-        end
-
-        describe "#[]=" do
-          context 'with a simple file_name and binary content' do
-            let(:file_name) { 'foo.txt' }
-            let(:content) { SecureRandom.random_bytes(20) }
-            let(:location) { FileSystem.storage_location + '/' + file_name }
-
-            it 'writes the given file contents to the given file name' do
-              expect(File.exist?(location)).to be false
-              FileSystem[file_name] = content
-              expect(File.binread(location)).to eq(content)
-            end
-          end
-
-          it 'creates any needed intermediary directories' do
-            expect(File.exist?(FileSystem.storage_location + '/a')).to be false
-            FileSystem["a/b"] = "bar"
-            expect(File.read(FileSystem.storage_location + '/a/b')).to 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")
-            expect(FileSystem.absolute_path_to_file("bar/bazz.json")).to eq(expected)
-          end
-
-          it "returns nil if the storage_location is not set" do
-            FileSystem.storage_location = nil
-            expect(FileSystem.absolute_path_to_file("bar/bazz.json")).to be_nil
-          end
-
-          it "sanitizes the file name" do
-            expected = File.join(FileSystem.storage_location, "_t_i-t_1_2_f_n.json")
-            expect(FileSystem.absolute_path_to_file("\nt \t!  i-t_1.2_f n.json")).to eq(expected)
-
-            expected = File.join(FileSystem.storage_location, "a_1/b")
-            expect(FileSystem.absolute_path_to_file("a 1/b")).to eq(expected)
-          end
-
-          it 'handles files with no extensions (even when there is a dot in the path)' do
-            expected = File.join(FileSystem.storage_location, "/foo_bar/baz_qux")
-            expect(FileSystem.absolute_path_to_file("/foo.bar/baz qux")).to eq(expected)
-          end
-        end
-      end
-    end
-  end
-end
-

data/spec/lib/vcr/cassette/persisters_spec.rb

@@ -1,39 +0,0 @@
-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
-            allow(subject).to receive :warn
-          end
-
-          it 'overrides the existing persister' do
-            subject[:foo] = :new_persister
-            expect(subject[:foo]).to be(:new_persister)
-          end
-
-          it 'warns that there is a name collision' do
-            expect(subject).to 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
-          expect(subject[:file_system]).to be(VCR::Cassette::Persisters::FileSystem)
-        end
-      end
-    end
-  end
-end
-