vcr 0.2.0 → 0.3.0

data/features/support/env.rb

@@ -12,7 +12,7 @@ end
 require 'spec/expectations'
 
 VCR.config do |c|
-  c.cache_dir = File.join(File.dirname(__FILE__), '..', 'fixtures', 'vcr_cassettes', RUBY_VERSION)
+  c.cassette_library_dir = File.join(File.dirname(__FILE__), '..', 'fixtures', 'vcr_cassettes', RUBY_VERSION)
 end
 
 VCR.module_eval do
@@ -31,25 +31,25 @@ end
 
 Before do |scenario|
   VCR.current_cucumber_scenario = scenario
-  temp_dir = File.join(VCR::Config.cache_dir, 'temp')
+  temp_dir = File.join(VCR::Config.cassette_library_dir, 'temp')
   FileUtils.rm_rf(temp_dir) if File.exist?(temp_dir)
 end
 
 Before('@copy_not_the_real_response_to_temp') do
-  orig_file = File.join(VCR::Config.cache_dir, 'not_the_real_response.yml')
-  temp_file = File.join(VCR::Config.cache_dir, 'temp', 'not_the_real_response.yml')
-  FileUtils.mkdir_p(File.join(VCR::Config.cache_dir, 'temp'))
+  orig_file = File.join(VCR::Config.cassette_library_dir, 'not_the_real_response.yml')
+  temp_file = File.join(VCR::Config.cassette_library_dir, 'temp', 'not_the_real_response.yml')
+  FileUtils.mkdir_p(File.join(VCR::Config.cassette_library_dir, 'temp'))
   FileUtils.cp orig_file, temp_file
 end
 
 at_exit do
   %w(record_cassette1 record_cassette2).each do |tag|
-    cache_file = File.join(VCR::Config.cache_dir, 'cucumber_tags', "#{tag}.yml")
-    FileUtils.rm_rf(cache_file) if File.exist?(cache_file)
+    file = File.join(VCR::Config.cassette_library_dir, 'cucumber_tags', "#{tag}.yml")
+    FileUtils.rm_rf(file) if File.exist?(file)
   end
 end
 
 VCR.cucumber_tags do |t|
-  t.tags '@record_cassette1', '@record_cassette2', :record => :unregistered
+  t.tags '@record_cassette1', '@record_cassette2', :record => :new_episodes
   t.tags '@replay_cassette1', '@replay_cassette2', '@replay_cassette3', :record => :none
 end

data/lib/vcr.rb

@@ -1,6 +1,7 @@
 require 'vcr/cassette'
 require 'vcr/config'
 require 'vcr/cucumber_tags'
+require 'vcr/deprecations'
 require 'vcr/recorded_response'
 
 require 'vcr/extensions/fake_web'
@@ -14,23 +15,23 @@ module VCR
     cassettes.last
   end
 
-  def create_cassette!(*args)
+  def insert_cassette(*args)
     cassette = Cassette.new(*args)
     cassettes.push(cassette)
     cassette
   end
 
-  def destroy_cassette!
+  def eject_cassette
     cassette = cassettes.pop
-    cassette.destroy! if cassette
+    cassette.eject if cassette
     cassette
   end
 
-  def with_cassette(*args)
-    create_cassette!(*args)
+  def use_cassette(*args)
+    insert_cassette(*args)
     yield
   ensure
-    destroy_cassette!
+    eject_cassette
   end
 
   def config

data/lib/vcr/cassette.rb

@@ -3,20 +3,21 @@ require 'yaml'
 
 module VCR
   class Cassette
-    VALID_RECORD_MODES = [:all, :none, :unregistered].freeze
+    VALID_RECORD_MODES = [:all, :none, :new_episodes].freeze
 
     attr_reader :name, :record_mode
 
     def initialize(name, options = {})
       @name = name
       @record_mode = options[:record] || VCR::Config.default_cassette_options[:record]
+      deprecate_unregistered_record_mode
       @allow_real_http_lambda = allow_real_http_lambda_for(options[:allow_real_http] || VCR::Config.default_cassette_options[:allow_real_http])
       self.class.raise_error_unless_valid_record_mode(record_mode)
       set_fakeweb_allow_net_connect
       load_recorded_responses
     end
 
-    def destroy!
+    def eject
       write_recorded_responses_to_disk
       deregister_original_recorded_responses
       restore_fakeweb_allow_net_conect
@@ -30,8 +31,8 @@ module VCR
       recorded_responses << recorded_response
     end
 
-    def cache_file
-      File.join(VCR::Config.cache_dir, "#{name.to_s.gsub(/[^\w\-\/]+/, '_')}.yml") if VCR::Config.cache_dir
+    def file
+      File.join(VCR::Config.cassette_library_dir, "#{name.to_s.gsub(/[^\w\-\/]+/, '_')}.yml") if VCR::Config.cassette_library_dir
     end
 
     def self.raise_error_unless_valid_record_mode(record_mode)
@@ -44,14 +45,12 @@ module VCR
       @allow_real_http_lambda ? @allow_real_http_lambda.call(uri) : false
     end
 
-    private
-
     def new_recorded_responses
       recorded_responses - @original_recorded_responses
     end
 
     def should_allow_net_connect?
-      [:unregistered, :all].include?(record_mode)
+      [:new_episodes, :all].include?(record_mode)
     end
 
     def set_fakeweb_allow_net_connect
@@ -67,8 +66,8 @@ module VCR
       @original_recorded_responses = []
       return if record_mode == :all
 
-      if cache_file
-        @original_recorded_responses = File.open(cache_file, 'r') { |f| YAML.load(f.read) } if File.exist?(cache_file)
+      if file
+        @original_recorded_responses = File.open(file, 'r') { |f| YAML.load(f.read) } if File.exist?(file)
         recorded_responses.replace(@original_recorded_responses)
       end
 
@@ -86,10 +85,10 @@ module VCR
     end
 
     def write_recorded_responses_to_disk
-      if VCR::Config.cache_dir && new_recorded_responses.size > 0
-        directory = File.dirname(cache_file)
+      if VCR::Config.cassette_library_dir && new_recorded_responses.size > 0
+        directory = File.dirname(file)
         FileUtils.mkdir_p directory unless File.exist?(directory)
-        File.open(cache_file, 'w') { |f| f.write recorded_responses.to_yaml }
+        File.open(file, 'w') { |f| f.write recorded_responses.to_yaml }
       end
     end
 

data/lib/vcr/config.rb

@@ -3,21 +3,16 @@ require 'fileutils'
 module VCR
   class Config
     class << self
-      attr_reader :cache_dir
-      def cache_dir=(cache_dir)
-        @cache_dir = cache_dir
-        FileUtils.mkdir_p(cache_dir) if cache_dir
+      attr_reader :cassette_library_dir
+      def cassette_library_dir=(cassette_library_dir)
+        @cassette_library_dir = cassette_library_dir
+        FileUtils.mkdir_p(cassette_library_dir) if cassette_library_dir
       end
 
       attr_writer :default_cassette_options
       def default_cassette_options
         @default_cassette_options ||= {}
       end
-
-      def default_cassette_record_mode=(value)
-        warn %Q{WARNING: #default_cassette_record_mode is deprecated.  Instead, use: "default_cassette_options = { :record => :#{value.to_s} }"}
-        default_cassette_options.merge!(:record => value)
-      end
     end
   end
 end

data/lib/vcr/cucumber_tags.rb

@@ -23,11 +23,11 @@ module VCR
 
         @main_object.instance_eval do
           Before(tag_name) do
-            VCR.create_cassette!(cassette_name, options)
+            VCR.insert_cassette(cassette_name, options)
           end
 
           After(tag_name) do
-            VCR.destroy_cassette!
+            VCR.eject_cassette
           end
         end
         self.class.add_tag(tag_name)

data/lib/vcr/deprecations.rb

@@ -0,0 +1,54 @@
+module VCR
+  def create_cassette!(*args)
+    warn "WARNING: VCR.create_cassette! is deprecated.  Instead, use: VCR.insert_cassette."
+    insert_cassette(*args)
+  end
+
+  def destroy_cassette!(*args)
+    warn "WARNING: VCR.destroy_cassette! is deprecated.  Instead, use: VCR.eject_cassette."
+    eject_cassette(*args)
+  end
+
+  def with_cassette(*args, &block)
+    warn "WARNING: VCR.with_cassette is deprecated.  Instead, use: VCR.use_cassette."
+    use_cassette(*args, &block)
+  end
+
+  class Cassette
+    def destroy!(*args)
+      warn "WARNING: VCR::Cassette#destroy! is deprecated.  Instead, use: VCR::Cassette#eject."
+      eject(*args)
+    end
+
+    def cache_file(*args)
+      warn "WARNING: VCR::Cassette#cache_file is deprecated.  Instead, use: VCR::Cassette#file."
+      file(*args)
+    end
+
+    private
+
+    def deprecate_unregistered_record_mode
+      if @record_mode == :unregistered
+        @record_mode = :new_episodes
+        Kernel.warn "WARNING: VCR's :unregistered record mode is deprecated.  Instead, use: :new_episodes."
+      end
+    end
+  end
+
+  class Config
+    def self.cache_dir(*args)
+      warn "WARNING: VCR::Config.cache_dir is deprecated.  Instead, use: VCR::Config.cassette_library_dir."
+      cassette_library_dir(*args)
+    end
+
+    def self.cache_dir=(value)
+      warn "WARNING: VCR::Config.cache_dir= is deprecated.  Instead, use: VCR::Config.cassette_library_dir=."
+      self.cassette_library_dir = value
+    end
+
+    def self.default_cassette_record_mode=(value)
+      warn %Q{WARNING: #default_cassette_record_mode is deprecated.  Instead, use: "default_cassette_options = { :record => :#{value.to_s} }"}
+      default_cassette_options.merge!(:record => value)
+    end
+  end
+end

data/spec/cassette_spec.rb

@@ -1,28 +1,28 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe VCR::Cassette do
-  describe '#cache_file' do
-    temp_dir File.expand_path(File.dirname(__FILE__) + '/fixtures/cache_file'), :assign_to_cache_dir => true
+  describe '#file' do
+    temp_dir File.expand_path(File.dirname(__FILE__) + '/fixtures/file'), :assign_to_cassette_library_dir => true
 
-    it 'combines the cache_dir with the cassette name' do
-      cassette = VCR::Cassette.new('the_cache_file')
-      cassette.cache_file.should == File.join(VCR::Config.cache_dir, 'the_cache_file.yml')
+    it 'combines the cassette_library_dir with the cassette name' do
+      cassette = VCR::Cassette.new('the_file')
+      cassette.file.should == File.join(VCR::Config.cassette_library_dir, 'the_file.yml')
     end
 
     it 'strips out disallowed characters so that it is a valid file name with no spaces' do
       cassette = VCR::Cassette.new("\nthis \t!  is-the_13212_file name")
-      cassette.cache_file.should =~ /#{Regexp.escape('_this_is-the_13212_file_name.yml')}$/
+      cassette.file.should =~ /#{Regexp.escape('_this_is-the_13212_file_name.yml')}$/
     end
 
     it 'keeps any path separators' do
       cassette = VCR::Cassette.new("dir/file_name")
-      cassette.cache_file.should =~ /#{Regexp.escape('dir/file_name.yml')}$/
+      cassette.file.should =~ /#{Regexp.escape('dir/file_name.yml')}$/
     end
 
-    it 'returns nil if the cache_dir is not set' do
-      VCR::Config.cache_dir = nil
-      cassette = VCR::Cassette.new('the_cache_file')
-      cassette.cache_file.should be_nil
+    it 'returns nil if the cassette_library_dir is not set' do
+      VCR::Config.cassette_library_dir = nil
+      cassette = VCR::Cassette.new('the_file')
+      cassette.file.should be_nil
     end
   end
 
@@ -49,7 +49,7 @@ describe VCR::Cassette do
       end
     end
 
-    { :unregistered => true, :all => true, :none => false }.each do |record_mode, allow_fakeweb_connect|
+    { :new_episodes => true, :all => true, :none => false }.each do |record_mode, allow_fakeweb_connect|
       it "sets FakeWeb.allow_net_connect to #{allow_fakeweb_connect} when the record mode is #{record_mode}" do
         FakeWeb.allow_net_connect = !allow_fakeweb_connect
         VCR::Cassette.new(:name, :record => record_mode)
@@ -57,9 +57,9 @@ describe VCR::Cassette do
       end
     end
 
-    { :unregistered => true, :all => false, :none => true }.each do |record_mode, load_responses|
-      it "#{load_responses ? 'loads' : 'does not load'} the recorded responses from the cached yml file when the record mode is #{record_mode}" do
-        VCR::Config.cache_dir = File.expand_path(File.dirname(__FILE__) + "/fixtures/#{RUBY_VERSION}/cassette_spec")
+    { :new_episodes => true, :all => false, :none => true }.each do |record_mode, load_responses|
+      it "#{load_responses ? 'loads' : 'does not load'} the recorded responses from the library yml file when the record mode is #{record_mode}" do
+        VCR::Config.cassette_library_dir = File.expand_path(File.dirname(__FILE__) + "/fixtures/#{RUBY_VERSION}/cassette_spec")
         cassette = VCR::Cassette.new('example', :record => record_mode)
 
         if load_responses
@@ -84,7 +84,7 @@ describe VCR::Cassette do
       end
 
       it "#{load_responses ? 'registers' : 'does not register'} the recorded responses with fakeweb when the record mode is #{record_mode}" do
-        VCR::Config.cache_dir = File.expand_path(File.dirname(__FILE__) + "/fixtures/#{RUBY_VERSION}/cassette_spec")
+        VCR::Config.cassette_library_dir = File.expand_path(File.dirname(__FILE__) + "/fixtures/#{RUBY_VERSION}/cassette_spec")
         cassette = VCR::Cassette.new('example', :record => record_mode)
 
         rr1 = FakeWeb.response_for(:get, "http://example.com")
@@ -141,14 +141,14 @@ describe VCR::Cassette do
     end
   end
 
-  describe '#destroy!' do
-    temp_dir File.expand_path(File.dirname(__FILE__) + '/fixtures/cassette_spec_destroy'), :assign_to_cache_dir => true
+  describe '#eject' do
+    temp_dir File.expand_path(File.dirname(__FILE__) + '/fixtures/cassette_spec_eject'), :assign_to_cassette_library_dir => true
 
     [true, false].each do |orig_allow_net_connect|
-      it "resets FakeWeb.allow_net_connect #{orig_allow_net_connect} if it was originally #{orig_allow_net_connect}" do
+      it "resets FakeWeb.allow_net_connect to #{orig_allow_net_connect} if it was originally #{orig_allow_net_connect}" do
         FakeWeb.allow_net_connect = orig_allow_net_connect
         cassette = VCR::Cassette.new(:name)
-        cassette.destroy!
+        cassette.eject
         FakeWeb.allow_net_connect?.should == orig_allow_net_connect
       end
     end
@@ -160,55 +160,55 @@ describe VCR::Cassette do
         VCR::RecordedResponse.new(:get,  'http://google.com',  :get_google_dot_come_response)
       ]
 
-      cassette = VCR::Cassette.new(:destroy_test)
+      cassette = VCR::Cassette.new(:eject_test)
       cassette.stub!(:recorded_responses).and_return(recorded_responses)
 
-      lambda { cassette.destroy! }.should change { File.exist?(cassette.cache_file) }.from(false).to(true)
-      saved_recorded_responses = File.open(cassette.cache_file, "r") { |f| YAML.load(f.read) }
+      lambda { cassette.eject }.should change { File.exist?(cassette.file) }.from(false).to(true)
+      saved_recorded_responses = File.open(cassette.file, "r") { |f| YAML.load(f.read) }
       saved_recorded_responses.should == recorded_responses
     end
 
-    it "writes the recorded responses a subdirectory if the cassette name includes a directory" do
+    it "writes the recorded responses to a subdirectory if the cassette name includes a directory" do
       recorded_responses = [VCR::RecordedResponse.new(:get,  'http://example.com', :get_example_dot_come_response)]
       cassette = VCR::Cassette.new('subdirectory/test_cassette')
       cassette.stub!(:recorded_responses).and_return(recorded_responses)
 
-      lambda { cassette.destroy! }.should change { File.exist?(cassette.cache_file) }.from(false).to(true)
-      saved_recorded_responses = File.open(cassette.cache_file, "r") { |f| YAML.load(f.read) }
+      lambda { cassette.eject }.should change { File.exist?(cassette.file) }.from(false).to(true)
+      saved_recorded_responses = File.open(cassette.file, "r") { |f| YAML.load(f.read) }
       saved_recorded_responses.should == recorded_responses
     end
 
     it "writes both old and new recorded responses to disk" do
-      cache_file = File.expand_path(File.dirname(__FILE__) + "/fixtures/#{RUBY_VERSION}/cassette_spec/example.yml")
-      FileUtils.cp cache_file, File.join(@temp_dir, 'previously_recorded_responses.yml')
+      file = File.expand_path(File.dirname(__FILE__) + "/fixtures/#{RUBY_VERSION}/cassette_spec/example.yml")
+      FileUtils.cp file, File.join(@temp_dir, 'previously_recorded_responses.yml')
       cassette = VCR::Cassette.new('previously_recorded_responses')
       cassette.should have(3).recorded_responses
       new_recorded_response = VCR::RecordedResponse.new(:get, 'http://example.com/bar', :example_dot_com_bar_response)
       cassette.store_recorded_response!(new_recorded_response)
-      cassette.destroy!
-      saved_recorded_responses = File.open(cassette.cache_file, "r") { |f| YAML.load(f.read) }
+      cassette.eject
+      saved_recorded_responses = File.open(cassette.file, "r") { |f| YAML.load(f.read) }
       saved_recorded_responses.should have(4).recorded_responses
       saved_recorded_responses.last.should == new_recorded_response
     end
   end
 
-  describe '#destroy for a cassette with previously recorded responses' do
+  describe '#eject for a cassette with previously recorded responses' do
     it "de-registers the recorded responses from fakeweb" do
-      VCR::Config.cache_dir = File.expand_path(File.dirname(__FILE__) + "/fixtures/#{RUBY_VERSION}/cassette_spec")
+      VCR::Config.cassette_library_dir = File.expand_path(File.dirname(__FILE__) + "/fixtures/#{RUBY_VERSION}/cassette_spec")
       cassette = VCR::Cassette.new('example', :record => :none)
       FakeWeb.registered_uri?(:get, 'http://example.com').should be_true
       FakeWeb.registered_uri?(:get, 'http://example.com/foo').should be_true
-      cassette.destroy!
+      cassette.eject
       FakeWeb.registered_uri?(:get, 'http://example.com').should be_false
       FakeWeb.registered_uri?(:get, 'http://example.com/foo').should be_false
     end
 
     it "does not re-write to disk the previously recorded resposes if there are no new ones" do
-      VCR::Config.cache_dir = File.expand_path(File.dirname(__FILE__) + "/fixtures/#{RUBY_VERSION}/cassette_spec")
-      yaml_file = File.join(VCR::Config.cache_dir, 'example.yml')
+      VCR::Config.cassette_library_dir = File.expand_path(File.dirname(__FILE__) + "/fixtures/#{RUBY_VERSION}/cassette_spec")
+      yaml_file = File.join(VCR::Config.cassette_library_dir, 'example.yml')
       cassette = VCR::Cassette.new('example', :record => :none)
-      File.should_not_receive(:open).with(cassette.cache_file, 'w')
-      lambda { cassette.destroy! }.should_not change { File.mtime(yaml_file) }
+      File.should_not_receive(:open).with(cassette.file, 'w')
+      lambda { cassette.eject }.should_not change { File.mtime(yaml_file) }
     end
   end
 end

data/spec/config_spec.rb

@@ -1,15 +1,15 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe VCR::Config do
-  describe '#cache_dir=' do
+  describe '#cassette_library_dir=' do
     temp_dir(File.expand_path(File.dirname(__FILE__) + '/fixtures/config_spec'))
 
     it 'creates the directory if it does not exist' do
-      lambda { VCR::Config.cache_dir = @temp_dir }.should change { File.exist?(@temp_dir) }.from(false).to(true)
+      lambda { VCR::Config.cassette_library_dir = @temp_dir }.should change { File.exist?(@temp_dir) }.from(false).to(true)
     end
 
     it 'does not raise an error if given nil' do
-      lambda { VCR::Config.cache_dir = nil }.should_not raise_error
+      lambda { VCR::Config.cassette_library_dir = nil }.should_not raise_error
     end
   end
 
@@ -19,29 +19,4 @@ describe VCR::Config do
       VCR::Config.default_cassette_options.should == {}
     end
   end
-
-  describe '#default_cassette_record_mode=' do
-    disable_warnings
-
-    it 'sets the default_cassette_options[:record] option' do
-      VCR::Cassette::VALID_RECORD_MODES.each do |mode|
-        VCR::Config.default_cassette_options = nil
-        VCR::Config.default_cassette_record_mode = mode
-        VCR::Config.default_cassette_options[:record].should == mode
-      end
-    end
-
-    it 'merges the :record option with the existing default_cassette_record options' do
-      VCR::Config.default_cassette_options = { :an => :option }
-      VCR::Config.default_cassette_record_mode = :all
-      VCR::Config.default_cassette_options.should == { :an => :option, :record => :all }
-    end
-
-    it 'warns the user that it is deprecated' do
-      VCR::Cassette::VALID_RECORD_MODES.each do |mode|
-        VCR::Config.should_receive(:warn).with(%Q{WARNING: #default_cassette_record_mode is deprecated.  Instead, use: "default_cassette_options = { :record => :#{mode.to_s} }"})
-        VCR::Config.default_cassette_record_mode = mode
-      end
-    end
-  end
 end