social_url_stats 0.0.1

data/vendor/ruby/1.9.1/gems/vcr-2.8.0/spec/vcr/cassette/migrator_spec.rb

@@ -0,0 +1,195 @@
+require 'tmpdir'
+require 'vcr/cassette/migrator'
+
+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...
+  before(:each) do
+    YAML::ENGINE.yamler = 'syck' if defined?(YAML::ENGINE)
+  end
+
+  after(:each) do
+    YAML::ENGINE.yamler = 'psych' if defined?(YAML::ENGINE)
+  end
+
+  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
+      pending "psych not available" unless defined?(YAML::ENGINE)
+      YAML::ENGINE.yamler = 'psych'
+    end
+
+    it_behaves_like "ignoring invalid YAML"
+  end
+end
+

data/vendor/ruby/1.9.1/gems/vcr-2.8.0/spec/vcr/cassette/persisters/file_system_spec.rb

@@ -0,0 +1,69 @@
+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
+          it 'writes the given file contents to the given file name' do
+            expect(File.exist?(FileSystem.storage_location + '/foo.txt')).to be false
+            FileSystem["foo.txt"] = "bar"
+            expect(File.read(FileSystem.storage_location + '/foo.txt')).to eq("bar")
+          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/vendor/ruby/1.9.1/gems/vcr-2.8.0/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
+            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
+

data/vendor/ruby/1.9.1/gems/vcr-2.8.0/spec/vcr/cassette/serializers_spec.rb

@@ -0,0 +1,176 @@
+require 'support/ruby_interpreter'
+require 'vcr/cassette/serializers'
+require 'multi_json'
+
+begin
+  require 'psych' # ensure psych is loaded for these tests if its available
+rescue LoadError
+end
+
+module VCR
+  class Cassette
+    describe Serializers do
+      shared_examples_for "encoding error handling" do |name, error_class|
+        context "the #{name} serializer" do
+          it 'appends info about the :preserve_exact_body_bytes option to the error' do
+            expect {
+              result = serializer.serialize("a" => string)
+              serializer.deserialize(result)
+            }.to raise_error(error_class, /preserve_exact_body_bytes/)
+          end unless (RUBY_INTERPRETER == :rubinius && RUBY_VERSION =~ /^1.9/)
+        end
+      end
+
+      shared_examples_for "a serializer" do |name, file_extension, lazily_loaded|
+        let(:serializer) { subject[name] }
+
+        context "the #{name} serializer" do
+          it 'lazily loads the serializer' do
+            serializers = subject.instance_variable_get(:@serializers)
+            expect(serializers).not_to have_key(name)
+            expect(subject[name]).not_to be_nil
+            expect(serializers).to have_key(name)
+          end if lazily_loaded
+
+          it "returns '#{file_extension}' as the file extension" do
+            expect(serializer.file_extension).to eq(file_extension)
+          end
+
+          it "can serialize and deserialize a hash" do
+            hash = { "a" => 7, "nested" => { "hash" => [1, 2, 3] }}
+            serialized = serializer.serialize(hash)
+            expect(serialized).not_to eq(hash)
+            expect(serialized).to be_a(String)
+            deserialized = serializer.deserialize(serialized)
+            expect(deserialized).to eq(hash)
+          end
+        end
+      end
+
+      it_behaves_like "a serializer", :yaml,  "yml",  :lazily_loaded do
+        it_behaves_like "encoding error handling", :yaml, ArgumentError do
+          let(:string) { "\xFA".force_encoding("UTF-8") }
+          before { ::YAML::ENGINE.yamler = 'psych' }
+        end if ''.respond_to?(:encoding)
+      end
+
+      it_behaves_like "a serializer", :syck,  "yml",  :lazily_loaded do
+        it_behaves_like "encoding error handling", :syck, ArgumentError do
+          let(:string) { "\xFA".force_encoding("UTF-8") }
+        end if ''.respond_to?(:encoding)
+      end
+
+      it_behaves_like "a serializer", :psych, "yml",  :lazily_loaded do
+        it_behaves_like "encoding error handling", :psych, ArgumentError do
+          let(:string) { "\xFA".force_encoding("UTF-8") }
+        end if ''.respond_to?(:encoding)
+      end if RUBY_VERSION =~ /1.9/
+
+      it_behaves_like "a serializer", :json,  "json", :lazily_loaded do
+        engines = {}
+
+        if RUBY_INTERPRETER == :jruby
+          # don't test yajl on jruby
+        else
+          engines[:yajl] = MultiJson::LoadError
+        end
+
+        if RUBY_VERSION =~ /1.9/
+          engines[:json_gem] = EncodingError
+
+          # Disable json_pure for now due to this bug:
+          # https://github.com/flori/json/issues/186
+          # engines[:json_pure] = EncodingError
+        end
+
+        engines.each do |engine, error|
+          context "when MultiJson is configured to use #{engine.inspect}", :unless => (RUBY_INTERPRETER == :jruby) do
+            before { MultiJson.engine = engine }
+            it_behaves_like "encoding error handling", :json, error do
+              let(:string) { "\xFA" }
+            end
+          end
+        end
+      end
+
+      context "a custom :ruby serializer" do
+        let(:custom_serializer) do
+          Object.new.tap do |obj|
+            def obj.file_extension
+              "rb"
+            end
+
+            def obj.serialize(hash)
+              hash.inspect
+            end
+
+            def obj.deserialize(string)
+              eval(string)
+            end
+          end
+        end
+
+        before(:each) do
+          subject[:ruby] = custom_serializer
+        end
+
+        it_behaves_like "a serializer", :ruby, "rb", false
+      end
+
+      describe "#[]=" do
+        context 'when there is already a serializer registered for the given name' do
+          before(:each) do
+            subject[:foo] = :old_serializer
+            allow(subject).to receive :warn
+          end
+
+          it 'overrides the existing serializer' do
+            subject[:foo] = :new_serializer
+            expect(subject[:foo]).to be(:new_serializer)
+          end
+
+          it 'warns that there is a name collision' do
+            expect(subject).to receive(:warn).with(
+              /WARNING: There is already a VCR cassette serializer registered for :foo\. Overriding it/
+            )
+            subject[:foo] = :new_serializer
+          end
+        end
+      end
+
+      describe "#[]" do
+        it 'raises an error when given an unrecognized serializer name' do
+          expect { subject[:foo] }.to raise_error(ArgumentError)
+        end
+
+        it 'returns the named serializer' do
+          expect(subject[:yaml]).to be(VCR::Cassette::Serializers::YAML)
+        end
+      end
+
+      # see https://gist.github.com/815769
+      problematic_syck_string = "1\n \n2"
+
+      describe "psych serializer" do
+        it 'serializes things using pysch even if syck is configured as the default YAML engine' do
+          ::YAML::ENGINE.yamler = 'syck'
+          serialized = subject[:psych].serialize(problematic_syck_string)
+          expect(subject[:psych].deserialize(serialized)).to eq(problematic_syck_string)
+        end if defined?(::Psych)
+
+        it 'raises an error if psych cannot be loaded' do
+          expect { subject[:psych] }.to raise_error(LoadError)
+        end unless defined?(::Psych)
+      end
+
+      describe "syck serializer" do
+        it 'forcibly serializes things using syck even if psych is the currently configured YAML engine' do
+          ::YAML::ENGINE.yamler = 'psych'
+          serialized = subject[:syck].serialize(problematic_syck_string)
+          expect(subject[:syck].deserialize(serialized)).not_to eq(problematic_syck_string)
+        end if defined?(::Psych) && (RUBY_INTERPRETER != :jruby) && (RUBY_VERSION.to_f < 2.0)
+      end
+    end
+  end
+end
+