vcr 0.1.0

data/features/support/env.rb

@@ -0,0 +1,55 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
+require 'vcr'
+
+begin
+  require 'ruby-debug'
+  Debugger.start
+  Debugger.settings[:autoeval] = true if Debugger.respond_to?(:settings)
+rescue LoadError
+  # ruby-debug wasn't available so neither can the debugging be
+end
+
+require 'spec/expectations'
+
+VCR.config do |c|
+  c.cache_dir = File.join(File.dirname(__FILE__), '..', 'fixtures', 'vcr_cassettes', RUBY_VERSION)
+end
+
+VCR.module_eval do
+  def self.completed_cucumber_scenarios
+    @completed_cucumber_scenarios ||= []
+  end
+
+  class << self
+    attr_accessor :current_cucumber_scenario
+  end
+end
+
+After do |scenario|
+  VCR.completed_cucumber_scenarios << scenario
+end
+
+Before do |scenario|
+  VCR.current_cucumber_scenario = scenario
+  temp_dir = File.join(VCR::Config.cache_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'))
+  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)
+  end
+end
+
+VCR.cucumber_tags do |t|
+  t.tags '@record_cassette1', '@record_cassette2', :record => :unregistered
+  t.tags '@replay_cassette1', '@replay_cassette2', :record => :none
+end

data/lib/vcr.rb

@@ -0,0 +1,48 @@
+require 'vcr/cassette'
+require 'vcr/config'
+require 'vcr/cucumber_tags'
+require 'vcr/fake_web_extensions'
+require 'vcr/net_http_extensions'
+require 'vcr/recorded_response'
+
+module VCR
+  extend self
+
+  def current_cassette
+    cassettes.last
+  end
+
+  def create_cassette!(*args)
+    cassette = Cassette.new(*args)
+    cassettes.push(cassette)
+    cassette
+  end
+
+  def destroy_cassette!
+    cassette = cassettes.pop
+    cassette.destroy! if cassette
+    cassette
+  end
+
+  def with_cassette(*args)
+    create_cassette!(*args)
+    yield
+  ensure
+    destroy_cassette!
+  end
+
+  def config
+    yield VCR::Config
+  end
+
+  def cucumber_tags(&block)
+    main_object = eval('self', block.binding)
+    yield VCR::CucumberTags.new(main_object)
+  end
+
+  private
+
+  def cassettes
+    @cassettes ||= []
+  end
+end

data/lib/vcr/cassette.rb

@@ -0,0 +1,89 @@
+require 'fileutils'
+require 'yaml'
+
+module VCR
+  class Cassette
+    VALID_RECORD_MODES = [:all, :none, :unregistered].freeze
+
+    attr_reader :name, :record_mode
+
+    def initialize(name, options = {})
+      @name = name
+      @record_mode = options[:record] || VCR::Config.default_cassette_record_mode
+      self.class.raise_error_unless_valid_record_mode(record_mode)
+      set_fakeweb_allow_net_connect
+      load_recorded_responses
+    end
+
+    def destroy!
+      write_recorded_responses_to_disk
+      deregister_original_recorded_responses
+      restore_fakeweb_allow_net_conect
+    end
+
+    def recorded_responses
+      @recorded_responses ||= []
+    end
+
+    def store_recorded_response!(recorded_response)
+      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
+    end
+
+    def self.raise_error_unless_valid_record_mode(record_mode)
+      unless VALID_RECORD_MODES.include?(record_mode)
+        raise ArgumentError.new("#{record_mode} is not a valid cassette record mode.  Valid options are: #{VALID_RECORD_MODES.inspect}")
+      end
+    end
+
+    private
+
+    def new_recorded_responses
+      recorded_responses - @original_recorded_responses
+    end
+
+    def should_allow_net_connect?
+      [:unregistered, :all].include?(record_mode)
+    end
+
+    def set_fakeweb_allow_net_connect
+      @orig_fakeweb_allow_connect = FakeWeb.allow_net_connect?
+      FakeWeb.allow_net_connect = should_allow_net_connect?
+    end
+
+    def restore_fakeweb_allow_net_conect
+      FakeWeb.allow_net_connect = @orig_fakeweb_allow_connect
+    end
+
+    def load_recorded_responses
+      @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)
+        recorded_responses.replace(@original_recorded_responses)
+      end
+
+      recorded_responses.each do |rr|
+        FakeWeb.register_uri(rr.method, rr.uri, { :response => rr.response })
+      end
+    end
+
+    def write_recorded_responses_to_disk
+      if VCR::Config.cache_dir && new_recorded_responses.size > 0
+        directory = File.dirname(cache_file)
+        FileUtils.mkdir_p directory unless File.exist?(directory)
+        File.open(cache_file, 'w') { |f| f.write recorded_responses.to_yaml }
+      end
+    end
+
+    def deregister_original_recorded_responses
+      @original_recorded_responses.each do |rr|
+        FakeWeb.remove_from_registry(rr.method, rr.uri)
+      end
+    end
+  end
+end

data/lib/vcr/config.rb

@@ -0,0 +1,19 @@
+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
+      end
+
+      attr_reader :default_cassette_record_mode
+      def default_cassette_record_mode=(default_cassette_record_mode)
+        VCR::Cassette.raise_error_unless_valid_record_mode(default_cassette_record_mode)
+        @default_cassette_record_mode = default_cassette_record_mode
+      end
+    end
+  end
+end

data/lib/vcr/cucumber_tags.rb

@@ -0,0 +1,38 @@
+module VCR
+  class CucumberTags
+    class << self
+      def tags
+        @tags.dup
+      end
+
+      def add_tag(tag)
+        @tags << tag
+      end
+    end
+
+    @tags = []
+    def initialize(main_object)
+      @main_object = main_object
+    end
+
+    def tags(*tag_names)
+      options = tag_names.last.is_a?(::Hash) ? tag_names.pop : {}
+      tag_names.each do |tag_name|
+        tag_name = "@#{tag_name}" unless tag_name =~ /^@/
+        cassette_name = "cucumber_tags/#{tag_name.gsub(/\A@/, '')}"
+
+        @main_object.instance_eval do
+          Before(tag_name) do
+            VCR.create_cassette!(cassette_name, options)
+          end
+
+          After(tag_name) do
+            VCR.destroy_cassette!
+          end
+        end
+        self.class.add_tag(tag_name)
+      end
+    end
+    alias :tag :tags
+  end
+end

data/lib/vcr/fake_web_extensions.rb

@@ -0,0 +1,18 @@
+require 'fake_web'
+
+module FakeWeb
+  def self.remove_from_registry(method, url)
+    Registry.instance.remove(method, url)
+  end
+
+  class Registry #:nodoc:
+    def remove(method, url)
+      uri_map.delete_if do |uri, method_hash|
+        if normalize_uri(uri) == normalize_uri(url)
+          method_hash.delete(method)
+          method_hash.empty? # there's no point in keeping this entry in the uri map if its method hash is empty...
+        end
+      end
+    end
+  end
+end

data/lib/vcr/net_http_extensions.rb

@@ -0,0 +1,39 @@
+require 'net/http'
+
+module Net
+  class HTTP
+    def request_with_vcr(request, body = nil, &block)
+      response = request_without_vcr(request, body, &block)
+      __store_response_with_vcr__(response, request)
+      response
+    end
+    alias_method :request_without_vcr, :request
+    alias_method :request, :request_with_vcr
+
+    private
+
+    def __store_response_with_vcr__(response, request)
+      if cassette = VCR.current_cassette
+        # Copied from: http://github.com/chrisk/fakeweb/blob/fakeweb-1.2.8/lib/fake_web/ext/net_http.rb#L39-52
+        protocol = use_ssl? ? "https" : "http"
+
+        path = request.path
+        path = URI.parse(request.path).request_uri if request.path =~ /^http/
+
+        if request["authorization"] =~ /^Basic /
+          userinfo = FakeWeb::Utility.decode_userinfo_from_header(request["authorization"])
+          userinfo = FakeWeb::Utility.encode_unsafe_chars_in_userinfo(userinfo) + "@"
+        else
+          userinfo = ""
+        end
+
+        uri = "#{protocol}://#{userinfo}#{self.address}:#{self.port}#{path}"
+        method = request.method.downcase.to_sym
+
+        unless FakeWeb.registered_uri?(method, uri)
+          cassette.store_recorded_response!(VCR::RecordedResponse.new(method, uri, response))
+        end
+      end
+    end
+  end
+end

data/lib/vcr/recorded_response.rb

@@ -0,0 +1,4 @@
+module VCR
+  class RecordedResponse < Struct.new(:method, :uri, :response)
+  end
+end

data/spec/cassette_spec.rb

@@ -0,0 +1,185 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe VCR::Cassette do
+  before(:all) do
+    @orig_default_cassette_record_mode = VCR::Config.default_cassette_record_mode
+    VCR::Config.default_cassette_record_mode = :unregistered
+  end
+
+  after(:all) do
+    VCR::Config.default_cassette_record_mode = :unregistered
+  end
+
+  before(:each) do
+    FakeWeb.clean_registry
+  end
+
+  describe '#cache_file' do
+    temp_dir File.expand_path(File.dirname(__FILE__) + '/fixtures/cache_file'), :assign_to_cache_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')
+    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')}$/
+    end
+
+    it 'keeps any path separators' do
+      cassette = VCR::Cassette.new("dir/file_name")
+      cassette.cache_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
+    end
+  end
+
+  describe '#store_recorded_response!' do
+    it 'adds the recorded response to #recorded_responses' do
+      recorded_response = VCR::RecordedResponse.new(:get, 'http://example.com', :response)
+      cassette = VCR::Cassette.new(:test_cassette)
+      cassette.recorded_responses.should == []
+      cassette.store_recorded_response!(recorded_response)
+      cassette.recorded_responses.should == [recorded_response]
+    end
+  end
+
+  describe 'on creation' do
+    it "raises an error if given an invalid record mode" do
+      lambda { VCR::Cassette.new(:test, :record => :not_a_record_mode) }.should raise_error(ArgumentError)
+    end
+
+    VCR::Cassette::VALID_RECORD_MODES.each do |mode|
+      it "defaults the record mode to #{mode} when VCR::Config.default_cassette_record_mode is #{mode}" do
+        VCR::Config.default_cassette_record_mode = mode
+        cassette = VCR::Cassette.new(:test)
+        cassette.record_mode.should == mode
+      end
+    end
+
+    { :unregistered => 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)
+        FakeWeb.allow_net_connect?.should == allow_fakeweb_connect
+      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")
+        cassette = VCR::Cassette.new('example', :record => record_mode)
+
+        if load_responses
+          cassette.should have(2).recorded_responses
+
+          rr1, rr2 = cassette.recorded_responses.first, cassette.recorded_responses.last
+
+          rr1.method.should == :get
+          rr1.uri.should == 'http://example.com:80/'
+          rr1.response.body.should =~ /You have reached this web page by typing.+example\.com/
+
+          rr2.method.should == :get
+          rr2.uri.should == 'http://example.com:80/foo'
+          rr2.response.body.should =~ /foo was not found on this server/
+        else
+          cassette.should have(0).recorded_responses
+        end
+      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")
+        cassette = VCR::Cassette.new('example', :record => record_mode)
+
+        rr1 = FakeWeb.response_for(:get, "http://example.com")
+        rr2 = FakeWeb.response_for(:get, "http://example.com/foo")
+
+        if load_responses
+          rr1.should_not be_nil
+          rr2.should_not be_nil
+          rr1.body.should =~ /You have reached this web page by typing.+example\.com/
+          rr2.body.should =~ /foo was not found on this server/
+        else
+          rr1.should be_nil
+          rr2.should be_nil
+        end
+      end
+    end
+  end
+
+  describe '#destroy!' do
+    temp_dir File.expand_path(File.dirname(__FILE__) + '/fixtures/cassette_spec_destroy'), :assign_to_cache_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
+        FakeWeb.allow_net_connect = orig_allow_net_connect
+        cassette = VCR::Cassette.new(:name)
+        cassette.destroy!
+        FakeWeb.allow_net_connect?.should == orig_allow_net_connect
+      end
+    end
+
+    it "writes the recorded responses to disk as yaml" do
+      recorded_responses = [
+        VCR::RecordedResponse.new(:get,  'http://example.com', :get_example_dot_come_response),
+        VCR::RecordedResponse.new(:post, 'http://example.com', :post_example_dot_come_response),
+        VCR::RecordedResponse.new(:get,  'http://google.com',  :get_google_dot_come_response)
+      ]
+
+      cassette = VCR::Cassette.new(:destroy_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) }
+      saved_recorded_responses.should == recorded_responses
+    end
+
+    it "writes the recorded responses 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) }
+      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')
+      cassette = VCR::Cassette.new('previously_recorded_responses')
+      cassette.should have(2).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) }
+      saved_recorded_responses.should have(3).recorded_responses
+      saved_recorded_responses.last.should == new_recorded_response
+    end
+  end
+
+  describe '#destroy 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")
+      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!
+      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')
+      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) }
+    end
+  end
+end